From 467997f9da80f6892a850980f950880edad8a7a9 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 2 Feb 2017 00:28:24 +0100 Subject: [PATCH 01/26] Created dev branch for further testing. --- dist/bin/handlers.d.ts | 0 dist/bin/handlers.js | 50 + dist/bin/index.d.ts | 1 + dist/bin/index.js | 58 + dist/bin/status.d.ts | 0 dist/bin/status.js | 98 + dist/bus.d.ts | 1 + dist/bus.js | 4 + dist/bus/Bus.d.ts | 6 + dist/bus/Bus.js | 8 + dist/compiler.d.ts | 6 + dist/compiler.js | 7 + dist/compiler/Compiler.d.ts | 16 + dist/compiler/Compiler.js | 95 + dist/compiler/CompilerConfig.d.ts | 9 + dist/compiler/CompilerConfig.js | 1 + dist/compiler/CompilerMode.d.ts | 5 + dist/compiler/CompilerMode.js | 9 + dist/compiler/CompilerResult.d.ts | 7 + dist/compiler/CompilerResult.js | 1 + dist/compiler/FileResult.d.ts | 6 + dist/compiler/FileResult.js | 1 + dist/compiler/default_config.d.ts | 3 + dist/compiler/default_config.js | 11 + dist/compiler/transformers.d.ts | 8 + dist/compiler/transformers.js | 13 + .../FunctionDeclarationTransformer.d.ts | 7 + .../FunctionDeclarationTransformer.js | 47 + .../HasStatementsTransformer.d.ts | 8 + .../transformers/HasStatementsTransformer.js | 57 + dist/compiler/transformers/Transformer.d.ts | 16 + dist/compiler/transformers/Transformer.js | 39 + .../transformers/TransformerConfig.d.ts | 6 + .../transformers/TransformerConfig.js | 1 + .../VariableDeclarationTransformer.d.ts | 12 + .../VariableDeclarationTransformer.js | 80 + .../compiler/transformers/default_config.d.ts | 3 + dist/compiler/transformers/default_config.js | 8 + .../transformers/default_transformers.d.ts | 3 + .../transformers/default_transformers.js | 7 + dist/compiler/utils.d.ts | 2 + dist/compiler/utils.js | 3 + dist/compiler/utils/generator.d.ts | 4 + dist/compiler/utils/generator.js | 67 + dist/config.d.ts | 2 + dist/config.js | 3 + dist/config/Config.d.ts | 9 + dist/config/Config.js | 4 + dist/config/default_config.d.ts | 3 + dist/config/default_config.js | 10 + dist/index.d.ts | 1 + dist/index.js | 5 + dist/lib/r.d.ts | 1 + dist/lib/r.js | 5 + dist/lib/t.d.ts | 2 + dist/lib/t.js | 4 + dist/transform.d.ts | 4 + dist/transform.js | 30 + dist/writer.d.ts | 4 + dist/writer.js | 5 + dist/writer/Writer.d.ts | 10 + dist/writer/Writer.js | 37 + dist/writer/WriterConfig.d.ts | 6 + dist/writer/WriterConfig.js | 1 + dist/writer/WriterResult.d.ts | 7 + dist/writer/WriterResult.js | 1 + dist/writer/default_config.d.ts | 3 + dist/writer/default_config.js | 8 + src/bin/index.ts | 1 + src/bin/status.ts | 19 +- .../transformers/HasStatementsTransformer.ts | 6 +- .../Development/ts-runtime/src/bus.js | 1 + .../Development/ts-runtime/src/compiler.js | 6 + .../ts-runtime/src/compiler/Compiler.js | 94 + src/playground/index.ts | 21 +- src/playground/test.js | 19 + src/playground/test0.js | 78660 ++++++++++++++++ src/playground/test3.js | 6555 ++ src/playground/test4.js | 7 + src/playground/test4.ts | 5 + 80 files changed, 86336 insertions(+), 17 deletions(-) create mode 100644 dist/bin/handlers.d.ts create mode 100644 dist/bin/handlers.js create mode 100644 dist/bin/index.d.ts create mode 100644 dist/bin/index.js create mode 100644 dist/bin/status.d.ts create mode 100644 dist/bin/status.js create mode 100644 dist/bus.d.ts create mode 100644 dist/bus.js create mode 100644 dist/bus/Bus.d.ts create mode 100644 dist/bus/Bus.js create mode 100644 dist/compiler.d.ts create mode 100644 dist/compiler.js create mode 100644 dist/compiler/Compiler.d.ts create mode 100644 dist/compiler/Compiler.js create mode 100644 dist/compiler/CompilerConfig.d.ts create mode 100644 dist/compiler/CompilerConfig.js create mode 100644 dist/compiler/CompilerMode.d.ts create mode 100644 dist/compiler/CompilerMode.js create mode 100644 dist/compiler/CompilerResult.d.ts create mode 100644 dist/compiler/CompilerResult.js create mode 100644 dist/compiler/FileResult.d.ts create mode 100644 dist/compiler/FileResult.js create mode 100644 dist/compiler/default_config.d.ts create mode 100644 dist/compiler/default_config.js create mode 100644 dist/compiler/transformers.d.ts create mode 100644 dist/compiler/transformers.js create mode 100644 dist/compiler/transformers/FunctionDeclarationTransformer.d.ts create mode 100644 dist/compiler/transformers/FunctionDeclarationTransformer.js create mode 100644 dist/compiler/transformers/HasStatementsTransformer.d.ts create mode 100644 dist/compiler/transformers/HasStatementsTransformer.js create mode 100644 dist/compiler/transformers/Transformer.d.ts create mode 100644 dist/compiler/transformers/Transformer.js create mode 100644 dist/compiler/transformers/TransformerConfig.d.ts create mode 100644 dist/compiler/transformers/TransformerConfig.js create mode 100644 dist/compiler/transformers/VariableDeclarationTransformer.d.ts create mode 100644 dist/compiler/transformers/VariableDeclarationTransformer.js create mode 100644 dist/compiler/transformers/default_config.d.ts create mode 100644 dist/compiler/transformers/default_config.js create mode 100644 dist/compiler/transformers/default_transformers.d.ts create mode 100644 dist/compiler/transformers/default_transformers.js create mode 100644 dist/compiler/utils.d.ts create mode 100644 dist/compiler/utils.js create mode 100644 dist/compiler/utils/generator.d.ts create mode 100644 dist/compiler/utils/generator.js create mode 100644 dist/config.d.ts create mode 100644 dist/config.js create mode 100644 dist/config/Config.d.ts create mode 100644 dist/config/Config.js create mode 100644 dist/config/default_config.d.ts create mode 100644 dist/config/default_config.js create mode 100644 dist/index.d.ts create mode 100644 dist/index.js create mode 100644 dist/lib/r.d.ts create mode 100644 dist/lib/r.js create mode 100644 dist/lib/t.d.ts create mode 100644 dist/lib/t.js create mode 100644 dist/transform.d.ts create mode 100644 dist/transform.js create mode 100644 dist/writer.d.ts create mode 100644 dist/writer.js create mode 100644 dist/writer/Writer.d.ts create mode 100644 dist/writer/Writer.js create mode 100644 dist/writer/WriterConfig.d.ts create mode 100644 dist/writer/WriterConfig.js create mode 100644 dist/writer/WriterResult.d.ts create mode 100644 dist/writer/WriterResult.js create mode 100644 dist/writer/default_config.d.ts create mode 100644 dist/writer/default_config.js create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js create mode 100644 src/playground/test.js create mode 100644 src/playground/test0.js create mode 100644 src/playground/test3.js create mode 100644 src/playground/test4.js create mode 100644 src/playground/test4.ts diff --git a/dist/bin/handlers.d.ts b/dist/bin/handlers.d.ts new file mode 100644 index 0000000..e69de29 diff --git a/dist/bin/handlers.js b/dist/bin/handlers.js new file mode 100644 index 0000000..c8f9f22 --- /dev/null +++ b/dist/bin/handlers.js @@ -0,0 +1,50 @@ +"use strict"; +const cp = require("child_process"); +const path = require("path"); +const bus_1 = require("../bus"); +const child = cp.fork(path.join(__dirname, './status')); +child.send({ message: 'init' }); +child.on('exit', () => { + process.exit(); +}); +function handleError(error) { + child.send({ message: 'error', payload: error }); +} +process.on('uncaughtException', handleError); +process.on('unhandledRejection', handleError); +bus_1.bus.on('error', handleError); +bus_1.bus.on('main.start', (filePaths) => { + child.send({ message: 'start', payload: filePaths.length }); +}); +bus_1.bus.on('main.done', (filePaths) => { + child.send({ message: 'end' }); +}); +bus_1.bus.on('transform.file.start', (filePath) => { + child.send({ message: 'fileStart', payload: filePath }); +}); +bus_1.bus.on('transform.file.readError', (filePath) => { + child.send({ message: 'fileReadError', payload: filePath }); +}); +bus_1.bus.on('transform.file.done', (filePath) => { + child.send({ message: 'fileEnd', payload: filePath }); +}); +bus_1.bus.on('write.start', (num) => { + child.send({ message: 'writeStart', payload: num }); +}); +bus_1.bus.on('write.end', (num) => { + child.send({ message: 'writeEnd', payload: num }); +}); +bus_1.bus.on('write.file.start', (filePath) => { + child.send({ message: 'fileWriteStart', payload: filePath }); +}); +bus_1.bus.on('transform.file.done', (filePath) => { + child.send({ message: 'fileWriteEnd', payload: filePath }); +}); +// process.on('SIGINT', () => { +// child.send({message: 'term'}); +// }); +// +// process.on('SIGTERM', () => { +// process.stdin.resume(); +// child.send({message: 'term'}); +// }); diff --git a/dist/bin/index.d.ts b/dist/bin/index.d.ts new file mode 100644 index 0000000..637118d --- /dev/null +++ b/dist/bin/index.d.ts @@ -0,0 +1 @@ +import './handlers'; diff --git a/dist/bin/index.js b/dist/bin/index.js new file mode 100644 index 0000000..dfd4388 --- /dev/null +++ b/dist/bin/index.js @@ -0,0 +1,58 @@ +#!/usr/bin/env node +"use strict"; +require("./handlers"); +const program = require("commander"); +const transform_1 = require("../transform"); +const writer_1 = require("../writer"); +const pkg = require('../../package.json'); +const config = {}; +const writerConfig = writer_1.DEFAULT_CONFIG; +let write = false; +function defaultAction() { + const files = program.args.filter((value) => { + return typeof value === 'string'; + }); + transform_1.default(files) + .then((compilerResult) => { + if (write) { + const writer = new writer_1.Writer(compilerResult); + writer.writeAll(); + } + }); +} +function setNoAssertConst() { + config.assertConst = true; +} +function setEncoding(encoding) { + config.encoding = encoding; + writerConfig.encoding = encoding; +} +function setWrite(location, base) { + write = true; + writerConfig.writePath = location || writerConfig.writePath; + writerConfig.basePath = base || writerConfig.basePath; +} +program + .version(pkg.version) + .description(`--------- ts-runtime --------- + Inserts runtime type checks and + emits pretty printed TypeScript. + --------------------------------`) + .usage('[options] <file ...>') + .option('-w, --write', 'persist files', setWrite) + .option('-e, --encoding <encoding>', 'set file encoding. defaults to utf8', setEncoding) + .option('--no-assert-const', 'turn off const declaration checks.', setNoAssertConst) + .on('--help', () => { + console.log(' Examples:'); + console.log(); + console.log(' $ tsr --no-assert-const file.ts'); + console.log(' $ tsr --write ./out ./src ./src/file1.ts ./src/file2.ts'); + console.log(); +}); +program.parse(process.argv); +if (!process.argv.slice(2).length) { + program.outputHelp(); +} +else { + defaultAction(); +} diff --git a/dist/bin/status.d.ts b/dist/bin/status.d.ts new file mode 100644 index 0000000..e69de29 diff --git a/dist/bin/status.js b/dist/bin/status.js new file mode 100644 index 0000000..984cfb3 --- /dev/null +++ b/dist/bin/status.js @@ -0,0 +1,98 @@ +"use strict"; +const path = require("path"); +const ora = require("ora"); +const chalk = require("chalk"); +const symbols = require("log-symbols"); +let spinner; +let fileCount = 0; +let processed = 0; +let errors = 0; +process.on('uncaughtException', (error) => { + status.error(error); +}); +process.on('unhandledRejection', (reason, p) => { + status.error(new Error(reason)); +}); +process.on('SIGINT', () => { + status.term(); + process.exit(); +}); +process.on('SIGTERM', () => { + status.term(); + process.exit(); +}); +process.on('message', (data) => { + if (typeof status[data.message] === 'function') { + status[data.message](data.payload); + } +}); +const status = {}; +status.init = () => { + spinner = null; + fileCount = 0; + processed = 0; + errors = 0; + spinner = ora(); +}; +status.start = (num) => { + fileCount = num; + spinner.text = chalk.bold(`Got ${num} file${num === 1 ? '' : 's'} to process:`); + spinner.stopAndPersist(); + spinner.text = `${processed}/${fileCount}`; + spinner.start(); + return spinner; +}; +status.end = () => { + if (errors > 0) { + spinner.stopAndPersist({ symbol: symbols.warning, text: chalk.yellow(`All processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`) }); + } + else { + spinner.succeed(chalk.green('All files have been processed')); + } + process.exit(0); +}; +status.term = () => { + spinner.fail(chalk.red('Processing was interrupted')); +}; +status.fileStart = (filePath) => { + processed++; + const countStr = chalk.gray(`[${processed}/${fileCount}]`); + spinner.text = `${countStr} Processing ${path.basename(filePath)}`; +}; +status.fileEnd = (filePath) => { + const countStr = chalk.gray(`[${processed}/${fileCount}]`); + spinner.succeed(`${countStr} Done processing ${path.basename(filePath)}`); + spinner.start(); +}; +status.fileFail = (filePath) => { + errors++; + const countStr = chalk.gray(`[${processed}/${fileCount}]`); + spinner.fail(`${countStr} Error processing ${path.basename(filePath)}`); + spinner.start(); +}; +status.fileReadError = (filePath) => { + errors++; + const countStr = chalk.gray(`[${processed}/${fileCount}]`); + spinner.fail(`${countStr} Could not read ${path.basename(filePath)}`); + spinner.start(); +}; +status.writeStart = (num) => { + spinner.text = `Writing files`; +}; +status.writeEnd = (num) => { + spinner.succeed(`Wrote ${num} files`); +}; +status.fileWriteStart = (filePath) => { +}; +status.fileWriteEnd = (filePath) => { +}; +status.error = (err) => { + errors++; + if (typeof err === 'string') { + spinner.fail(chalk.red(err)); + } + if (err instanceof Error) { + spinner.fail(chalk.red(err.message)); + } + process.exit(); +}; diff --git a/dist/bus.d.ts b/dist/bus.d.ts new file mode 100644 index 0000000..6ec1e45 --- /dev/null +++ b/dist/bus.d.ts @@ -0,0 +1 @@ +export { EventBus, bus } from './bus/Bus'; diff --git a/dist/bus.js b/dist/bus.js new file mode 100644 index 0000000..ead0d45 --- /dev/null +++ b/dist/bus.js @@ -0,0 +1,4 @@ +"use strict"; +var Bus_1 = require("./bus/Bus"); +exports.EventBus = Bus_1.EventBus; +exports.bus = Bus_1.bus; diff --git a/dist/bus/Bus.d.ts b/dist/bus/Bus.d.ts new file mode 100644 index 0000000..b1b0032 --- /dev/null +++ b/dist/bus/Bus.d.ts @@ -0,0 +1,6 @@ +/// <reference types="node" /> +import * as EventEmitter from 'events'; +export declare class EventBus extends EventEmitter { +} +export declare const bus: EventBus; +export default bus; diff --git a/dist/bus/Bus.js b/dist/bus/Bus.js new file mode 100644 index 0000000..5f35bcc --- /dev/null +++ b/dist/bus/Bus.js @@ -0,0 +1,8 @@ +"use strict"; +const EventEmitter = require("events"); +class EventBus extends EventEmitter { +} +exports.EventBus = EventBus; +exports.bus = new EventBus(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports.bus; diff --git a/dist/compiler.d.ts b/dist/compiler.d.ts new file mode 100644 index 0000000..27992e1 --- /dev/null +++ b/dist/compiler.d.ts @@ -0,0 +1,6 @@ +export { FileResult } from './compiler/FileResult'; +export { Compiler } from './compiler/Compiler'; +export { CompilerResult } from './compiler/CompilerResult'; +export { CompilerMode } from './compiler/CompilerMode'; +export { CompilerConfig } from './compiler/CompilerConfig'; +export { DEFAULT_CONFIG } from './compiler/default_config'; diff --git a/dist/compiler.js b/dist/compiler.js new file mode 100644 index 0000000..0c3c0a2 --- /dev/null +++ b/dist/compiler.js @@ -0,0 +1,7 @@ +"use strict"; +var Compiler_1 = require("./compiler/Compiler"); +exports.Compiler = Compiler_1.Compiler; +var CompilerMode_1 = require("./compiler/CompilerMode"); +exports.CompilerMode = CompilerMode_1.CompilerMode; +var default_config_1 = require("./compiler/default_config"); +exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG; diff --git a/dist/compiler/Compiler.d.ts b/dist/compiler/Compiler.d.ts new file mode 100644 index 0000000..e026531 --- /dev/null +++ b/dist/compiler/Compiler.d.ts @@ -0,0 +1,16 @@ +import * as ts from 'typescript'; +import { Config } from '../config'; +import { Transformer } from './transformers'; +import CompilerResult from './CompilerResult'; +export declare class Compiler { + protected config: Config; + protected transformers: Transformer[]; + constructor(config: Config, transformers?: Transformer[]); + process(): Promise<CompilerResult>; + protected onSubstituteNode(context: ts.EmitContext, node: ts.Node): ts.Node; + private transformFile(filePath, transformers); + private visit(node); + private visitChildrenFirst(node); + private visitParentFirst(node); +} +export default Compiler; diff --git a/dist/compiler/Compiler.js b/dist/compiler/Compiler.js new file mode 100644 index 0000000..4e4a0a5 --- /dev/null +++ b/dist/compiler/Compiler.js @@ -0,0 +1,95 @@ +"use strict"; +// import * as fs from 'fs'; +const path = require("path"); +const ts = require("typescript"); +const transformers_1 = require("./transformers"); +const bus_1 = require("../bus"); +const CompilerMode_1 = require("./CompilerMode"); +class Compiler { + constructor(config, transformers) { + this.config = config; + this.transformers = []; + const transformersToEnable = transformers || transformers_1.DEFAULT_TRANSFORMERS; + transformers_1.Transformer.DEFAULT_CONFIG = config; + const enabledTtransformers = Object.keys(transformersToEnable) + .map((key) => { + return transformers ? + transformers[key] : + new transformersToEnable[key](); + }); + this.transformers.push(...enabledTtransformers); + } + process() { + bus_1.bus.emit('compiler.start', this.config); + const toTransform = []; + const transform = (context) => (sourceFile) => { + context.onSubstituteNode = this.onSubstituteNode.bind(this); + for (const transformer of this.transformers) { + for (const substitution of transformer.getSubstitutions()) { + context.enableSubstitution(substitution); + } + } + return sourceFile; + }; + for (const file of this.config.files) { + toTransform.push(this.transformFile(file, [transform])); + } + // Do not reject this promise, if individual files fail + return Promise.all(toTransform.map(p => p.catch(e => e))) + .then(results => { + bus_1.bus.emit('compiler.done', this.config); + return { + config: this.config, + fileResults: results, + }; + }); + } + onSubstituteNode(context, node) { + let substitutedNode = node; + let parent = node.parent; + for (const transformer of this.transformers) { + substitutedNode = transformer.process(substitutedNode, context); + } + return substitutedNode; + } + transformFile(filePath, transformers) { + bus_1.bus.emit('transform.file.start', filePath); + return new Promise((resolve, reject) => { + filePath = path.normalize(path.join(process.cwd(), filePath)); + const fileName = path.basename(filePath); + const source = ts.sys.readFile(filePath, this.config.encoding); + if (source === undefined) { + bus_1.bus.emit('transform.file.readError', filePath); + return reject(`Error reading ${filePath}`); + } + let sourceFile = ts.createSourceFile(fileName, source, this.config.languageVersion || ts.ScriptTarget.Latest, this.config.setParentNodes || true, this.config.scriptKind || ts.ScriptKind.TS); + if (this.config.mode === CompilerMode_1.default.Visit) { + transformers = []; + sourceFile = this.visit(sourceFile); + } + const result = ts.emit(sourceFile, transformers).result; + bus_1.bus.emit('transform.file.done', filePath); + resolve({ + fileName, + filePath, + result, + }); + }); + } + visit(node) { + return this.config.visitChildrenFirst ? + this.visitChildrenFirst(node) : + this.visitParentFirst(node); + } + visitChildrenFirst(node) { + node = ts.visitEachChild(node, this.visitChildrenFirst.bind(this)); + return this.onSubstituteNode(undefined, node); + } + visitParentFirst(node) { + node = this.onSubstituteNode(undefined, node); + return ts.visitEachChild(node, this.visitParentFirst.bind(this)); + } +} +exports.Compiler = Compiler; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Compiler; diff --git a/dist/compiler/CompilerConfig.d.ts b/dist/compiler/CompilerConfig.d.ts new file mode 100644 index 0000000..7ce0aac --- /dev/null +++ b/dist/compiler/CompilerConfig.d.ts @@ -0,0 +1,9 @@ +import CompilerMode from './CompilerMode'; +import TransformerConfig from './transformers/TransformerConfig'; +export interface CompilerConfig extends TransformerConfig { + files?: string[]; + encoding?: string; + mode?: CompilerMode; + visitChildrenFirst?: boolean; +} +export default CompilerConfig; diff --git a/dist/compiler/CompilerConfig.js b/dist/compiler/CompilerConfig.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/compiler/CompilerConfig.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/compiler/CompilerMode.d.ts b/dist/compiler/CompilerMode.d.ts new file mode 100644 index 0000000..1f9608a --- /dev/null +++ b/dist/compiler/CompilerMode.d.ts @@ -0,0 +1,5 @@ +export declare enum CompilerMode { + Substitute = 1, + Visit = 2, +} +export default CompilerMode; diff --git a/dist/compiler/CompilerMode.js b/dist/compiler/CompilerMode.js new file mode 100644 index 0000000..6abbfcd --- /dev/null +++ b/dist/compiler/CompilerMode.js @@ -0,0 +1,9 @@ +"use strict"; +(function (CompilerMode) { + CompilerMode[CompilerMode["Substitute"] = 1] = "Substitute"; + CompilerMode[CompilerMode["Visit"] = 2] = "Visit"; +})(exports.CompilerMode || (exports.CompilerMode = {})); +var CompilerMode = exports.CompilerMode; +; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = CompilerMode; diff --git a/dist/compiler/CompilerResult.d.ts b/dist/compiler/CompilerResult.d.ts new file mode 100644 index 0000000..b880e24 --- /dev/null +++ b/dist/compiler/CompilerResult.d.ts @@ -0,0 +1,7 @@ +import FileResult from './FileResult'; +import { Config } from '../config'; +export interface CompilerResult { + config: Config; + fileResults: FileResult[]; +} +export default CompilerResult; diff --git a/dist/compiler/CompilerResult.js b/dist/compiler/CompilerResult.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/compiler/CompilerResult.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/compiler/FileResult.d.ts b/dist/compiler/FileResult.d.ts new file mode 100644 index 0000000..d12c004 --- /dev/null +++ b/dist/compiler/FileResult.d.ts @@ -0,0 +1,6 @@ +export interface FileResult { + result: string; + filePath: string; + fileName: string; +} +export default FileResult; diff --git a/dist/compiler/FileResult.js b/dist/compiler/FileResult.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/compiler/FileResult.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/compiler/default_config.d.ts b/dist/compiler/default_config.d.ts new file mode 100644 index 0000000..461370e --- /dev/null +++ b/dist/compiler/default_config.d.ts @@ -0,0 +1,3 @@ +import CompilerConfig from './CompilerConfig'; +export declare const DEFAULT_CONFIG: CompilerConfig; +export default DEFAULT_CONFIG; diff --git a/dist/compiler/default_config.js b/dist/compiler/default_config.js new file mode 100644 index 0000000..a0e18b9 --- /dev/null +++ b/dist/compiler/default_config.js @@ -0,0 +1,11 @@ +"use strict"; +const default_config_1 = require("./transformers/default_config"); +const CompilerMode_1 = require("./CompilerMode"); +exports.DEFAULT_CONFIG = Object.assign({}, { + files: [], + encoding: 'utf8', + mode: CompilerMode_1.default.Substitute, + visitChildrenFirst: false, +}, default_config_1.default); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports.DEFAULT_CONFIG; diff --git a/dist/compiler/transformers.d.ts b/dist/compiler/transformers.d.ts new file mode 100644 index 0000000..bbe8236 --- /dev/null +++ b/dist/compiler/transformers.d.ts @@ -0,0 +1,8 @@ +export { Transformer } from './transformers/Transformer'; +export { VariableDeclarationTransformer } from './transformers/VariableDeclarationTransformer'; +export { FunctionDeclarationTransformer } from './transformers/FunctionDeclarationTransformer'; +export { HasStatementsTransformer } from './transformers/HasStatementsTransformer'; +export { TransformerConfig } from './transformers/TransformerConfig'; +import * as DEFAULT_TRANSFORMERS from './transformers/default_transformers'; +export { DEFAULT_TRANSFORMERS }; +export { DEFAULT_CONFIG } from './transformers/default_config'; diff --git a/dist/compiler/transformers.js b/dist/compiler/transformers.js new file mode 100644 index 0000000..c401611 --- /dev/null +++ b/dist/compiler/transformers.js @@ -0,0 +1,13 @@ +"use strict"; +var Transformer_1 = require("./transformers/Transformer"); +exports.Transformer = Transformer_1.Transformer; +var VariableDeclarationTransformer_1 = require("./transformers/VariableDeclarationTransformer"); +exports.VariableDeclarationTransformer = VariableDeclarationTransformer_1.VariableDeclarationTransformer; +var FunctionDeclarationTransformer_1 = require("./transformers/FunctionDeclarationTransformer"); +exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer_1.FunctionDeclarationTransformer; +var HasStatementsTransformer_1 = require("./transformers/HasStatementsTransformer"); +exports.HasStatementsTransformer = HasStatementsTransformer_1.HasStatementsTransformer; +const DEFAULT_TRANSFORMERS = require("./transformers/default_transformers"); +exports.DEFAULT_TRANSFORMERS = DEFAULT_TRANSFORMERS; +var default_config_1 = require("./transformers/default_config"); +exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG; diff --git a/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts b/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts new file mode 100644 index 0000000..4b5b398 --- /dev/null +++ b/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts @@ -0,0 +1,7 @@ +import * as ts from 'typescript'; +import { Transformer } from './Transformer'; +export declare class FunctionDeclarationTransformer extends Transformer { + protected substitution: ts.SyntaxKind; + protected transform(node: ts.FunctionDeclaration, context: ts.EmitContext): ts.Node; +} +export default FunctionDeclarationTransformer; diff --git a/dist/compiler/transformers/FunctionDeclarationTransformer.js b/dist/compiler/transformers/FunctionDeclarationTransformer.js new file mode 100644 index 0000000..bbca161 --- /dev/null +++ b/dist/compiler/transformers/FunctionDeclarationTransformer.js @@ -0,0 +1,47 @@ +"use strict"; +const ts = require("typescript"); +const Transformer_1 = require("./Transformer"); +const utils_1 = require("../utils"); +class FunctionDeclarationTransformer extends Transformer_1.Transformer { + constructor() { + super(...arguments); + this.substitution = ts.SyntaxKind.FunctionDeclaration; + } + transform(node, context) { + const typeDefinitions = []; + const typeChecks = []; + if (!node.parameters) { + return node; + } + for (const param of node.parameters) { + if (param.type === undefined) { + continue; + } + const paramName = param.name.getText(); + const typeDefinition = utils_1.generator.createTypeDefinition(param.type, `_${paramName}Type`); + const typeCheck = ts.factory.createStatement(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('param')), [], [ + ts.factory.createLiteral(paramName), + ts.factory.createIdentifier(`_${paramName}Type`), + param.questionToken === undefined ? ts.factory.createLiteral(false) : ts.factory.createLiteral(true), + ]), ts.factory.createIdentifier('assert')), [], [ts.factory.createIdentifier(paramName)])); + ts.factory.createStatement(utils_1.generator.createTypeCall(`_${paramName}Type`, 'assert', [ts.factory.createIdentifier(paramName)])); + typeDefinitions.push(typeDefinition); + typeChecks.push(typeCheck); + } + let returnTypeDefinition = []; + let returnTypeCheck = []; + if (node.type !== undefined) { + returnTypeDefinition.push(ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration('_returnType', undefined, ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('return')), [], [utils_1.generator.createTypeCalls(node.type)])), + ], undefined, ts.NodeFlags.Const))); + } + const paramList = ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList(typeDefinitions, undefined, ts.NodeFlags.Let)); + const body = node.body; + body.statements.unshift(paramList, ...returnTypeDefinition, ...typeChecks); + const updatedNode = ts.factory.updateFunctionDeclaration(node, node.decorators, node.modifiers, node.name, node.typeParameters, node.parameters, node.type, body); + return updatedNode; + } +} +exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = FunctionDeclarationTransformer; diff --git a/dist/compiler/transformers/HasStatementsTransformer.d.ts b/dist/compiler/transformers/HasStatementsTransformer.d.ts new file mode 100644 index 0000000..6cee40c --- /dev/null +++ b/dist/compiler/transformers/HasStatementsTransformer.d.ts @@ -0,0 +1,8 @@ +import * as ts from 'typescript'; +import Transformer from './Transformer'; +export declare class HasStatementsTransformer extends Transformer { + protected substitution: ts.SyntaxKind[]; + protected transform(node: ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause): ts.Node; + private createFunctionAnnotation(node); +} +export default HasStatementsTransformer; diff --git a/dist/compiler/transformers/HasStatementsTransformer.js b/dist/compiler/transformers/HasStatementsTransformer.js new file mode 100644 index 0000000..69f6a10 --- /dev/null +++ b/dist/compiler/transformers/HasStatementsTransformer.js @@ -0,0 +1,57 @@ +"use strict"; +const ts = require("typescript"); +const Transformer_1 = require("./Transformer"); +const utils_1 = require("../utils"); +// type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause; +// export { HasStatementsNode }; +class HasStatementsTransformer extends Transformer_1.default { + constructor() { + super(...arguments); + this.substitution = [ + ts.SyntaxKind.SourceFile, + ts.SyntaxKind.Block, + ts.SyntaxKind.ModuleBlock, + ts.SyntaxKind.CaseClause, + ts.SyntaxKind.DefaultClause, + ]; + } + transform(node) { + if (!Array.isArray(node.statements)) { + return node; + } + const statements = node.statements; + let i = 0; + for (const statement of node.statements) { + if (statement.kind !== ts.SyntaxKind.FunctionDeclaration) { + continue; + } + const annotation = this.createFunctionAnnotation(statement); + statements.splice(++i, 0, annotation); + } + node.statements = statements; + return node; + } + createFunctionAnnotation(node) { + const returnType = node.type; + const args = []; + for (const param of node.parameters) { + args.push(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('param')), [], [ + ts.factory.createLiteral(param.name.getText()), + utils_1.generator.createTypeCalls(param.type), + ])); + } + if (node.type !== undefined) { + args.push(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('return')), [], [ + utils_1.generator.createTypeCalls(node.type), + ])); + } + const annotation = ts.factory.createStatement(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('annotate')), [], [ + ts.factory.createIdentifier(node.name.getText()), + ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('function')), [], args), + ])); + return annotation; + } +} +exports.HasStatementsTransformer = HasStatementsTransformer; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = HasStatementsTransformer; diff --git a/dist/compiler/transformers/Transformer.d.ts b/dist/compiler/transformers/Transformer.d.ts new file mode 100644 index 0000000..1abedbe --- /dev/null +++ b/dist/compiler/transformers/Transformer.d.ts @@ -0,0 +1,16 @@ +import * as ts from 'typescript'; +import { Config } from '../../config'; +export declare abstract class Transformer { + static DEFAULT_CONFIG: Config; + protected config: Config; + protected visited: ts.Node[]; + protected abstract substitution: ts.SyntaxKind | ts.SyntaxKind[]; + protected abstract transform(node: ts.Node, context?: ts.EmitContext): ts.Node; + constructor(config?: Config); + getSubstitutions(): ts.SyntaxKind[]; + getVisited(): ts.Node[]; + process(node: ts.Node, context?: ts.EmitContext): ts.Node; + protected wasGenerated(node: ts.Node): boolean; + protected wasVisited(node: ts.Node): boolean; +} +export default Transformer; diff --git a/dist/compiler/transformers/Transformer.js b/dist/compiler/transformers/Transformer.js new file mode 100644 index 0000000..2688bc8 --- /dev/null +++ b/dist/compiler/transformers/Transformer.js @@ -0,0 +1,39 @@ +"use strict"; +const config_1 = require("../../config"); +class Transformer { + constructor(config) { + this.visited = []; + this.config = config ? config : Transformer.DEFAULT_CONFIG; + } + getSubstitutions() { + return !Array.isArray(this.substitution) ? [this.substitution] : this.substitution; + } + getVisited() { + return this.visited; + } + process(node, context) { + if (this.config.skipGenerated && this.wasGenerated(node)) { + return node; + } + if (this.config.skipVisited) { + if (this.wasVisited(node)) { + return node; + } + this.visited.push(node); + } + if (this.getSubstitutions().indexOf(node.kind) === -1) { + return node; + } + return this.transform(node, context); + } + wasGenerated(node) { + return !node.parent; + } + wasVisited(node) { + return this.visited.indexOf(node) !== -1; + } +} +exports.Transformer = Transformer; +Transformer.DEFAULT_CONFIG = config_1.DEFAULT_CONFIG; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Transformer; diff --git a/dist/compiler/transformers/TransformerConfig.d.ts b/dist/compiler/transformers/TransformerConfig.d.ts new file mode 100644 index 0000000..3b14034 --- /dev/null +++ b/dist/compiler/transformers/TransformerConfig.d.ts @@ -0,0 +1,6 @@ +export interface TransformerConfig { + skipVisited?: boolean; + skipGenerated?: boolean; + assertConst?: boolean; +} +export default TransformerConfig; diff --git a/dist/compiler/transformers/TransformerConfig.js b/dist/compiler/transformers/TransformerConfig.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/compiler/transformers/TransformerConfig.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/compiler/transformers/VariableDeclarationTransformer.d.ts b/dist/compiler/transformers/VariableDeclarationTransformer.d.ts new file mode 100644 index 0000000..deb6d82 --- /dev/null +++ b/dist/compiler/transformers/VariableDeclarationTransformer.d.ts @@ -0,0 +1,12 @@ +import * as ts from 'typescript'; +import { Transformer } from './Transformer'; +export declare class VariableDeclarationTransformer extends Transformer { + protected substitution: ts.SyntaxKind; + protected transform(node: ts.VariableDeclarationList): ts.Node; + private transformDeclaration(node); + private transformLetDeclaration(node); + private transformConstDeclaration(node); + private transformUntypedLetDeclaration(node); + private transformUntypedConstDeclaration(node); +} +export default VariableDeclarationTransformer; diff --git a/dist/compiler/transformers/VariableDeclarationTransformer.js b/dist/compiler/transformers/VariableDeclarationTransformer.js new file mode 100644 index 0000000..bde8152 --- /dev/null +++ b/dist/compiler/transformers/VariableDeclarationTransformer.js @@ -0,0 +1,80 @@ +"use strict"; +const ts = require("typescript"); +const Transformer_1 = require("./Transformer"); +const utils_1 = require("../utils"); +class VariableDeclarationTransformer extends Transformer_1.Transformer { + constructor() { + super(...arguments); + this.substitution = ts.SyntaxKind.VariableDeclarationList; + } + transform(node) { + const declarations = []; + if (!node.declarations) { + return node; + } + for (const declaration of node.declarations) { + if (declaration.initializer) + if (declaration.kind === ts.SyntaxKind.VariableDeclaration) { + declarations.push(...this.transformDeclaration(declaration)); + continue; + } + declarations.push(declaration); + } + return ts.factory.updateVariableDeclarationList(node, declarations); + } + transformDeclaration(node) { + if (this.wasGenerated(node)) { + return [node]; + } + if (!node.type) { + if (node.parent.flags === ts.NodeFlags.Const) { + return this.transformUntypedConstDeclaration(node); + } + return this.transformUntypedLetDeclaration(node); + } + if (node.parent.flags === ts.NodeFlags.Const) { + return this.transformConstDeclaration(node); + } + return this.transformLetDeclaration(node); + } + transformLetDeclaration(node) { + const nodeName = node.name.getText(); + const typeDefinition = utils_1.generator.createTypeDefinition(node.type, `_${nodeName}Type`); + if (!node.initializer) { + return [typeDefinition, node]; + } + const initializer = utils_1.generator.createTypeCall(`_${nodeName}Type`, 'assert', [node.initializer]); + const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer); + return [typeDefinition, assignment]; + } + transformConstDeclaration(node) { + const nodeName = node.name.getText(); + const typeCalls = utils_1.generator.createTypeCalls(node.type); + const initializer = ts.factory.createCall(ts.factory.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer]); + const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer); + return [assignment]; + } + transformUntypedLetDeclaration(node) { + const nodeName = node.name.getText(); + const typeDefinition = utils_1.generator.createTypeDefinition('any', `_${nodeName}Type`); + if (!node.initializer) { + return [typeDefinition, node]; + } + const initializer = utils_1.generator.createTypeCall(`_${nodeName}Type`, 'assert', [node.initializer]); + const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer); + return [typeDefinition, assignment]; + } + transformUntypedConstDeclaration(node) { + if (!this.config.assertConst) { + return [node]; + } + const nodeName = node.name.getText(); + const typeCalls = utils_1.generator.createTypeCall('t', 'any'); + const initializer = ts.factory.createCall(ts.factory.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer]); + const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer); + return [assignment]; + } +} +exports.VariableDeclarationTransformer = VariableDeclarationTransformer; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = VariableDeclarationTransformer; diff --git a/dist/compiler/transformers/default_config.d.ts b/dist/compiler/transformers/default_config.d.ts new file mode 100644 index 0000000..f7d80de --- /dev/null +++ b/dist/compiler/transformers/default_config.d.ts @@ -0,0 +1,3 @@ +import TransformerConfig from './TransformerConfig'; +export declare const DEFAULT_CONFIG: TransformerConfig; +export default DEFAULT_CONFIG; diff --git a/dist/compiler/transformers/default_config.js b/dist/compiler/transformers/default_config.js new file mode 100644 index 0000000..995aa78 --- /dev/null +++ b/dist/compiler/transformers/default_config.js @@ -0,0 +1,8 @@ +"use strict"; +exports.DEFAULT_CONFIG = { + skipVisited: true, + skipGenerated: true, + assertConst: true, +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports.DEFAULT_CONFIG; diff --git a/dist/compiler/transformers/default_transformers.d.ts b/dist/compiler/transformers/default_transformers.d.ts new file mode 100644 index 0000000..17d936d --- /dev/null +++ b/dist/compiler/transformers/default_transformers.d.ts @@ -0,0 +1,3 @@ +export { FunctionDeclarationTransformer } from './FunctionDeclarationTransformer'; +export { HasStatementsTransformer } from './HasStatementsTransformer'; +export { VariableDeclarationTransformer } from './VariableDeclarationTransformer'; diff --git a/dist/compiler/transformers/default_transformers.js b/dist/compiler/transformers/default_transformers.js new file mode 100644 index 0000000..3a61e3e --- /dev/null +++ b/dist/compiler/transformers/default_transformers.js @@ -0,0 +1,7 @@ +"use strict"; +var FunctionDeclarationTransformer_1 = require("./FunctionDeclarationTransformer"); +exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer_1.FunctionDeclarationTransformer; +var HasStatementsTransformer_1 = require("./HasStatementsTransformer"); +exports.HasStatementsTransformer = HasStatementsTransformer_1.HasStatementsTransformer; +var VariableDeclarationTransformer_1 = require("./VariableDeclarationTransformer"); +exports.VariableDeclarationTransformer = VariableDeclarationTransformer_1.VariableDeclarationTransformer; diff --git a/dist/compiler/utils.d.ts b/dist/compiler/utils.d.ts new file mode 100644 index 0000000..7cb583f --- /dev/null +++ b/dist/compiler/utils.d.ts @@ -0,0 +1,2 @@ +import * as generator from './utils/generator'; +export { generator }; diff --git a/dist/compiler/utils.js b/dist/compiler/utils.js new file mode 100644 index 0000000..fbe5b72 --- /dev/null +++ b/dist/compiler/utils.js @@ -0,0 +1,3 @@ +"use strict"; +const generator = require("./utils/generator"); +exports.generator = generator; diff --git a/dist/compiler/utils/generator.d.ts b/dist/compiler/utils/generator.d.ts new file mode 100644 index 0000000..f207e2b --- /dev/null +++ b/dist/compiler/utils/generator.d.ts @@ -0,0 +1,4 @@ +import * as ts from 'typescript'; +export declare function createTypeDefinition(type: ts.TypeNode | string, name: string): ts.VariableDeclaration; +export declare function createTypeCalls(type: ts.TypeNode | string): ts.CallExpression; +export declare function createTypeCall(id: string, prop: string, args?: ts.Expression[], types?: ts.TypeNode[]): ts.CallExpression; diff --git a/dist/compiler/utils/generator.js b/dist/compiler/utils/generator.js new file mode 100644 index 0000000..8379984 --- /dev/null +++ b/dist/compiler/utils/generator.js @@ -0,0 +1,67 @@ +"use strict"; +const ts = require("typescript"); +function createTypeDefinition(type, name) { + return ts.factory.createVariableDeclaration(name, undefined, createTypeCalls(type)); +} +exports.createTypeDefinition = createTypeDefinition; +function createTypeCalls(type) { + if (!type) { + return null; + } + if (typeof type === 'string') { + return createTypeCall('t', type); + } + type = type; + switch (type.kind) { + case ts.SyntaxKind.BooleanKeyword: + case ts.SyntaxKind.NumberKeyword: + case ts.SyntaxKind.StringKeyword: + case ts.SyntaxKind.AnyKeyword: + { + return createTypeCall('t', type.getText()); + } + case ts.SyntaxKind.ArrayType: + { + const typeNode = type.elementType; + const callExpression = createTypeCall('t', 'array', [createTypeCalls(typeNode)]); + return callExpression; + } + case ts.SyntaxKind.TypeReference: + { + const typeRef = type; + const typeName = typeRef.typeName.getText(); + const args = []; + let callExpression; + if (typeRef.typeArguments) { + for (const arg of typeRef.typeArguments) { + args.push(createTypeCalls(arg)); + } + } + if (typeName === 'Array' || typeName === 'array') { + callExpression = createTypeCall('t', 'array', args); + } + else { + callExpression = createTypeCall('t', 'ref', [ts.factory.createIdentifier(typeName)]); + } + return callExpression; + } + case ts.SyntaxKind.TupleType: + { + const typeRef = type; + const args = []; + for (const arg of typeRef.elementTypes) { + args.push(createTypeCalls(arg)); + } + return createTypeCall('t', 'tuple', args); + } + default: + { + return createTypeCall('t', 'any'); + } + } +} +exports.createTypeCalls = createTypeCalls; +function createTypeCall(id, prop, args = [], types = []) { + return ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier(id), prop), types, args); +} +exports.createTypeCall = createTypeCall; diff --git a/dist/config.d.ts b/dist/config.d.ts new file mode 100644 index 0000000..3cfced7 --- /dev/null +++ b/dist/config.d.ts @@ -0,0 +1,2 @@ +export { Config } from './config/Config'; +export { DEFAULT_CONFIG } from './config/default_config'; diff --git a/dist/config.js b/dist/config.js new file mode 100644 index 0000000..7a00f68 --- /dev/null +++ b/dist/config.js @@ -0,0 +1,3 @@ +"use strict"; +var default_config_1 = require("./config/default_config"); +exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG; diff --git a/dist/config/Config.d.ts b/dist/config/Config.d.ts new file mode 100644 index 0000000..c0ca664 --- /dev/null +++ b/dist/config/Config.d.ts @@ -0,0 +1,9 @@ +import { ScriptTarget, ScriptKind } from 'typescript'; +import { CompilerConfig } from '../compiler/CompilerConfig'; +export interface Config extends CompilerConfig { + languageVersion?: ScriptTarget; + scriptKind?: ScriptKind; + setParentNodes?: boolean; +} +export { ScriptTarget, ScriptKind }; +export default Config; diff --git a/dist/config/Config.js b/dist/config/Config.js new file mode 100644 index 0000000..7893d40 --- /dev/null +++ b/dist/config/Config.js @@ -0,0 +1,4 @@ +"use strict"; +const typescript_1 = require("typescript"); +exports.ScriptTarget = typescript_1.ScriptTarget; +exports.ScriptKind = typescript_1.ScriptKind; diff --git a/dist/config/default_config.d.ts b/dist/config/default_config.d.ts new file mode 100644 index 0000000..d51a799 --- /dev/null +++ b/dist/config/default_config.d.ts @@ -0,0 +1,3 @@ +import { Config } from './Config'; +export declare const DEFAULT_CONFIG: Config; +export default DEFAULT_CONFIG; diff --git a/dist/config/default_config.js b/dist/config/default_config.js new file mode 100644 index 0000000..9a75027 --- /dev/null +++ b/dist/config/default_config.js @@ -0,0 +1,10 @@ +"use strict"; +const Config_1 = require("./Config"); +const default_config_1 = require("../compiler/default_config"); +exports.DEFAULT_CONFIG = Object.assign({}, { + languageVersion: Config_1.ScriptTarget.ES6, + scriptKind: Config_1.ScriptKind.TS, + setParentNodes: true, +}, default_config_1.default); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports.DEFAULT_CONFIG; diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..d5e7ab1 --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1 @@ +export * from './transform'; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..3521300 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,5 @@ +"use strict"; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +__export(require("./transform")); diff --git a/dist/lib/r.d.ts b/dist/lib/r.d.ts new file mode 100644 index 0000000..aa2f40f --- /dev/null +++ b/dist/lib/r.d.ts @@ -0,0 +1 @@ +export declare function getType(): void; diff --git a/dist/lib/r.js b/dist/lib/r.js new file mode 100644 index 0000000..94de928 --- /dev/null +++ b/dist/lib/r.js @@ -0,0 +1,5 @@ +"use strict"; +function getType() { + // returns either the parameter or t.ref(parameter); +} +exports.getType = getType; diff --git a/dist/lib/t.d.ts b/dist/lib/t.d.ts new file mode 100644 index 0000000..8f39e0f --- /dev/null +++ b/dist/lib/t.d.ts @@ -0,0 +1,2 @@ +import t from 'flow-runtime'; +export default t; diff --git a/dist/lib/t.js b/dist/lib/t.js new file mode 100644 index 0000000..3b25338 --- /dev/null +++ b/dist/lib/t.js @@ -0,0 +1,4 @@ +"use strict"; +const flow_runtime_1 = require("flow-runtime"); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = flow_runtime_1.default; diff --git a/dist/transform.d.ts b/dist/transform.d.ts new file mode 100644 index 0000000..36e1363 --- /dev/null +++ b/dist/transform.d.ts @@ -0,0 +1,4 @@ +import { CompilerResult } from './compiler'; +import { Config } from './config'; +export declare function transform(files?: string | string[], config?: Config): Promise<CompilerResult>; +export default transform; diff --git a/dist/transform.js b/dist/transform.js new file mode 100644 index 0000000..c782945 --- /dev/null +++ b/dist/transform.js @@ -0,0 +1,30 @@ +"use strict"; +const compiler_1 = require("./compiler"); +const config_1 = require("./config"); +const bus_1 = require("./bus"); +function transform(files, config = {}) { + config = getConfig(config); + config.files = getFiles(files || config.files); + bus_1.bus.emit('main.start', config.files); + return new compiler_1.Compiler(config) + .process() + .then(transformerResult => { + bus_1.bus.emit('main.done', config.files); + return transformerResult; + }); +} +exports.transform = transform; +function getConfig(config = {}) { + return Object.assign({}, config_1.DEFAULT_CONFIG, config); +} +function getFiles(files) { + if (typeof files === 'string') { + files = [files]; + } + if (!Array.isArray(files)) { + bus_1.bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.')); + } + return files; +} +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = transform; diff --git a/dist/writer.d.ts b/dist/writer.d.ts new file mode 100644 index 0000000..405f801 --- /dev/null +++ b/dist/writer.d.ts @@ -0,0 +1,4 @@ +export { Writer } from './writer/Writer'; +export { WriterConfig } from './writer/WriterConfig'; +export { WriterResult } from './writer/WriterResult'; +export { DEFAULT_CONFIG } from './writer/default_config'; diff --git a/dist/writer.js b/dist/writer.js new file mode 100644 index 0000000..b97038e --- /dev/null +++ b/dist/writer.js @@ -0,0 +1,5 @@ +"use strict"; +var Writer_1 = require("./writer/Writer"); +exports.Writer = Writer_1.Writer; +var default_config_1 = require("./writer/default_config"); +exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG; diff --git a/dist/writer/Writer.d.ts b/dist/writer/Writer.d.ts new file mode 100644 index 0000000..5c1be3b --- /dev/null +++ b/dist/writer/Writer.d.ts @@ -0,0 +1,10 @@ +import { CompilerResult, FileResult } from '../compiler'; +import WriterConfig from './WriterConfig'; +import WriterResult from './WriterResult'; +export declare class Writer { + private transformerResult; + constructor(transformerResult: CompilerResult); + writeAll(config?: WriterConfig): Promise<WriterResult[]>; + writeFile(fileResult: FileResult, config?: WriterConfig): Promise<WriterResult>; +} +export default Writer; diff --git a/dist/writer/Writer.js b/dist/writer/Writer.js new file mode 100644 index 0000000..960244d --- /dev/null +++ b/dist/writer/Writer.js @@ -0,0 +1,37 @@ +"use strict"; +const path = require("path"); +// import * as fs from 'fs'; +const ts = require("typescript"); +const default_config_1 = require("./default_config"); +const bus_1 = require("../bus"); +class Writer { + constructor(transformerResult) { + this.transformerResult = transformerResult; + } + writeAll(config) { + const toWrite = []; + for (const fileResult of this.transformerResult.fileResults) { + toWrite.push(this.writeFile(fileResult, config)); + } + return Promise.all(toWrite); + } + writeFile(fileResult, config) { + return new Promise((resolve, reject) => { + config = config ? Object.assign({}, default_config_1.default, config) : default_config_1.default; + const file = fileResult.filePath.replace(new RegExp(`^${config.basePath}`), ''); + let location = path.join(config.writePath, file); + location = path.join(path.dirname(path.join(config.writePath, file)), `${path.basename(location, '.ts')}.js`); + ts.sys.writeFile(location, fileResult.result); + bus_1.bus.emit('write.file.done', fileResult.filePath); + resolve({ + fileResult, + originalPath: fileResult.fileName, + writePath: location, + }); + bus_1.bus.emit('write.file.start', fileResult.filePath); + }); + } +} +exports.Writer = Writer; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Writer; diff --git a/dist/writer/WriterConfig.d.ts b/dist/writer/WriterConfig.d.ts new file mode 100644 index 0000000..8bd3409 --- /dev/null +++ b/dist/writer/WriterConfig.d.ts @@ -0,0 +1,6 @@ +export interface WriterConfig { + basePath: string; + writePath: string; + encoding?: string; +} +export default WriterConfig; diff --git a/dist/writer/WriterConfig.js b/dist/writer/WriterConfig.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/writer/WriterConfig.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/writer/WriterResult.d.ts b/dist/writer/WriterResult.d.ts new file mode 100644 index 0000000..86d8cc5 --- /dev/null +++ b/dist/writer/WriterResult.d.ts @@ -0,0 +1,7 @@ +import { FileResult } from '../compiler'; +export interface WriterResult { + fileResult: FileResult; + originalPath: string; + writePath: string; +} +export default WriterResult; diff --git a/dist/writer/WriterResult.js b/dist/writer/WriterResult.js new file mode 100644 index 0000000..3918c74 --- /dev/null +++ b/dist/writer/WriterResult.js @@ -0,0 +1 @@ +"use strict"; diff --git a/dist/writer/default_config.d.ts b/dist/writer/default_config.d.ts new file mode 100644 index 0000000..afc5203 --- /dev/null +++ b/dist/writer/default_config.d.ts @@ -0,0 +1,3 @@ +import WriterConfig from './WriterConfig'; +export declare const DEFAULT_CONFIG: WriterConfig; +export default DEFAULT_CONFIG; diff --git a/dist/writer/default_config.js b/dist/writer/default_config.js new file mode 100644 index 0000000..b4e70f1 --- /dev/null +++ b/dist/writer/default_config.js @@ -0,0 +1,8 @@ +"use strict"; +exports.DEFAULT_CONFIG = { + basePath: process.cwd(), + writePath: process.cwd(), + encoding: 'utf8', +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports.DEFAULT_CONFIG; diff --git a/src/bin/index.ts b/src/bin/index.ts index fee0b92..e4d5630 100644 --- a/src/bin/index.ts +++ b/src/bin/index.ts @@ -65,6 +65,7 @@ program.parse(process.argv); if (!process.argv.slice(2).length) { program.outputHelp(); + process.exit(); } else { defaultAction(); } diff --git a/src/bin/status.ts b/src/bin/status.ts index effa330..18f7b25 100644 --- a/src/bin/status.ts +++ b/src/bin/status.ts @@ -7,6 +7,8 @@ let spinner: any; let fileCount: number = 0; let processed: number = 0; let errors: number = 0; +let startWrite: number = 0; +let written: number = 0; process.on('uncaughtException', (error: Error) => { status.error(error); @@ -39,6 +41,8 @@ status.init = () => { fileCount = 0; processed = 0; errors = 0; + startWrite = 0; + written = 0; spinner = ora(); }; @@ -53,11 +57,20 @@ status.start = (num: number) => { status.end = () => { if (errors > 0) { - spinner.stopAndPersist({symbol: symbols.warning, text: chalk.yellow(`All processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`)}); + const text = chalk.yellow(`Processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`); + spinner.stopAndPersist({ symbol: symbols.warning, text }); } else { spinner.succeed(chalk.green('All files have been processed')); } + if (written < startWrite) { + const noFinish = startWrite - written; + const text = chalk.yellow(`${written} file${written === 1 ? '' : 's'} ${written === 1 ? 'has' : 'have'} been written, ${noFinish} did not finish`); + spinner.stopAndPersist({ symbol: symbols.warning, text }); + } else if (written > 0) { + spinner.succeed(chalk.green(`${written} file${written === 1 ? '' : 's'} ${written === 1 ? 'has' : 'have'} been written`)); + } + process.exit(0); }; @@ -100,11 +113,11 @@ status.writeEnd = (num: number) => { }; status.fileWriteStart = (filePath: string) => { - + startWrite++; }; status.fileWriteEnd = (filePath: string) => { - + written++; }; status.error = (err: any) => { diff --git a/src/compiler/transformers/HasStatementsTransformer.ts b/src/compiler/transformers/HasStatementsTransformer.ts index b7d12d2..fe01f8f 100644 --- a/src/compiler/transformers/HasStatementsTransformer.ts +++ b/src/compiler/transformers/HasStatementsTransformer.ts @@ -2,8 +2,8 @@ import * as ts from 'typescript'; import Transformer from './Transformer'; import { generator } from '../utils'; -type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause; -export { HasStatementsNode }; +// type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause; +// export { HasStatementsNode }; export class HasStatementsTransformer extends Transformer { @@ -15,7 +15,7 @@ export class HasStatementsTransformer extends Transformer { ts.SyntaxKind.DefaultClause, ]; - protected transform(node: HasStatementsNode): ts.Node { + protected transform(node: ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause): ts.Node { if (!Array.isArray(node.statements)) { return node; } diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js new file mode 100644 index 0000000..6ec1e45 --- /dev/null +++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js @@ -0,0 +1 @@ +export { EventBus, bus } from './bus/Bus'; diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js new file mode 100644 index 0000000..27992e1 --- /dev/null +++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js @@ -0,0 +1,6 @@ +export { FileResult } from './compiler/FileResult'; +export { Compiler } from './compiler/Compiler'; +export { CompilerResult } from './compiler/CompilerResult'; +export { CompilerMode } from './compiler/CompilerMode'; +export { CompilerConfig } from './compiler/CompilerConfig'; +export { DEFAULT_CONFIG } from './compiler/default_config'; diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js new file mode 100644 index 0000000..f8cf8d1 --- /dev/null +++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js @@ -0,0 +1,94 @@ +// import * as fs from 'fs'; +import * as path from 'path'; +import * as ts from 'typescript'; +import { Config } from '../config'; +import { Transformer, DEFAULT_TRANSFORMERS } from './transformers'; +import { bus } from '../bus'; +import CompilerMode from './CompilerMode'; +import CompilerResult from './CompilerResult'; +import FileResult from './FileResult'; +export class Compiler { + protected transformers: Transformer[] = []; + constructor(protected config: Config, transformers?: Transformer[]) { + const transformersToEnable = t.any().assert(transformers || DEFAULT_TRANSFORMERS); + Transformer.DEFAULT_CONFIG = config; + const enabledTtransformers = t.any().assert(Object.keys(transformersToEnable) + .map((key: string) => { + return transformers ? + (transformers as any)[key] as Transformer : + new (transformersToEnable as any)[key]() as Transformer; + })); + this.transformers.push(...enabledTtransformers); + } + public process(): Promise<CompilerResult> { + bus.emit('compiler.start', this.config); + const toTransform = t.array(t.ref(Promise)).assert([]); + const transform = t.ref(ts.Transformer).assert((context) => (sourceFile) => { + context.onSubstituteNode = this.onSubstituteNode.bind(this); + for (const transformer of this.transformers) { + for (const substitution of transformer.getSubstitutions()) { + context.enableSubstitution(substitution); + } + } + return sourceFile; + }); + for (const file of this.config.files) { + toTransform.push(this.transformFile(file, [transform])); + } + // Do not reject this promise, if individual files fail + return Promise.all(toTransform.map(p => p.catch(e => e))) + .then(results => { + bus.emit('compiler.done', this.config); + return { + config: this.config, + fileResults: results + }; + }); + } + protected onSubstituteNode(context: ts.EmitContext, node: ts.Node): ts.Node { + let _substitutedNodeType = t.any(), substitutedNode = _substitutedNodeType.assert(node); + let _parentType = t.any(), parent = _parentType.assert(node.parent); + for (const transformer of this.transformers) { + substitutedNode = transformer.process(substitutedNode, context); + } + return substitutedNode; + } + private transformFile(filePath: string, transformers: ts.Transformer[]): Promise<FileResult> { + bus.emit('transform.file.start', filePath); + return new Promise((resolve, reject) => { + filePath = path.normalize(path.join(process.cwd(), filePath)); + const fileName = t.any().assert(path.basename(filePath)); + const source = t.any().assert(ts.sys.readFile(filePath, this.config.encoding)); + if (source === undefined) { + bus.emit('transform.file.readError', filePath); + return reject("Error reading "filePath""); + } + let _sourceFileType = t.any(), sourceFile = _sourceFileType.assert(ts.createSourceFile(fileName, source, this.config.languageVersion || ts.ScriptTarget.Latest, this.config.setParentNodes || true, this.config.scriptKind || ts.ScriptKind.TS)); + if (this.config.mode === CompilerMode.Visit) { + transformers = []; + sourceFile = this.visit(sourceFile) as ts.SourceFile; + } + const result = t.any().assert(ts.emit(sourceFile, transformers).result); + bus.emit('transform.file.done', filePath); + resolve({ + fileName, + filePath, + result + }); + }); + } + private visit(node: ts.Node): ts.Node { + return this.config.visitChildrenFirst ? + this.visitChildrenFirst(node) : + this.visitParentFirst(node); + } + private visitChildrenFirst(node: ts.Node): ts.Node { + node = ts.visitEachChild(node, this.visitChildrenFirst.bind(this)); + return this.onSubstituteNode(undefined, node); + } + private visitParentFirst(node: ts.Node): ts.Node { + node = this.onSubstituteNode(undefined, node); + return ts.visitEachChild(node, this.visitParentFirst.bind(this)); + } +} +export default Compiler; diff --git a/src/playground/index.ts b/src/playground/index.ts index 36aae9b..b28ce4d 100644 --- a/src/playground/index.ts +++ b/src/playground/index.ts @@ -1,19 +1,18 @@ import * as path from 'path'; import * as tsr from '../index'; import { Config } from '../config'; -// import { Writer, WriterConfig } from '../writer'; +import { Writer, WriterConfig } from '../writer'; -const file1 = path.join(__dirname, 'test1.ts'); -const file2 = path.join(__dirname, 'test.ts'); +const file1 = path.join('test1.ts'); +const file2 = path.join('test.ts'); // const writerConfig: WriterConfig = { -// basePath: __dirname, -// writePath: __dirname, +// // basePath: __dirname, +// // writePath: __dirname, // }; -tsr.transform([file1, file2]); - -// .then(compilerResult => { -// const writer = new Writer(compilerResult); -// writer.writeAll(writerConfig); -// }); +tsr.transform([file1, file2]) +.then(compilerResult => { + const writer = new Writer(compilerResult); + writer.writeAll(); +}); diff --git a/src/playground/test.js b/src/playground/test.js new file mode 100644 index 0000000..bb5aeec --- /dev/null +++ b/src/playground/test.js @@ -0,0 +1,19 @@ +class A { +} +function f(param1: boolean, param2?: string[]): string { + let _param1Type = t.boolean(), _param2Type = t.array(t.string()); + const _returnType = t.return(t.string()); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let _xType = t.ref(ComplexType), x = _xType.assert(() => { + const a = t.boolean().assert(true); + return a; + }); + const b = t.number().assert(10); + let c; + let _dType = t.array(t.boolean()), d = _dType.assert([true, false]); + const e = t.array(t.array(t.array(t.number()))).assert([[[10]]]); + c = 'hi'; + let f; + return c; +} diff --git a/src/playground/test0.js b/src/playground/test0.js new file mode 100644 index 0000000..ce5a646 --- /dev/null +++ b/src/playground/test0.js @@ -0,0 +1,78660 @@ +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; diff --git a/src/playground/test3.js b/src/playground/test3.js new file mode 100644 index 0000000..afca512 --- /dev/null +++ b/src/playground/test3.js @@ -0,0 +1,6555 @@ +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; +function test(param1: string, param2?: boolean[]): [number, string] { + let _param1Type = t.string(), _param2Type = t.array(t.boolean()); + const _returnType = t.return(t.tuple(t.number(), t.string())); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let another; + const num = t.number().assert(10); + let _strType = t.string(), str = _strType.assert('hi'); + var _bbType = t.ref(Object), bb = _bbType.assert({}); + let u; // use any type + let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type + const y = t.any().assert('hi'); + x = 1; // TODO: check reassignments + return [num, str]; // TODO: check return value +} +let g; +let _eType = t.any(), e = _eType.assert(g = 10); +g = 'hi'; +g = 10; diff --git a/src/playground/test4.js b/src/playground/test4.js new file mode 100644 index 0000000..dcb0050 --- /dev/null +++ b/src/playground/test4.js @@ -0,0 +1,7 @@ +import { Test } from './test'; +function a(param1: string, param2?: Test[]) { + let _param1Type = t.string(), _param2Type = t.array(t.ref(Test)); + t.param("param1", _param1Type, false).assert(param1); + t.param("param2", _param2Type, true).assert(param2); + let _somethingType = t.boolean(), something = _somethingType.assert(getNumber()); +} diff --git a/src/playground/test4.ts b/src/playground/test4.ts new file mode 100644 index 0000000..84506a1 --- /dev/null +++ b/src/playground/test4.ts @@ -0,0 +1,5 @@ +import { Test } from './test'; + +function a(param1: string: param2?: Test[]) { + let something: boolean = getNumber(); +} From f8f5ca17021e465000d71d5c221a4c4287acb325 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Tue, 14 Mar 2017 22:02:55 +0100 Subject: [PATCH 02/26] Transition to the official transformer API. --- package.json | 6 +- src/next/bus.ts | 28 +++ src/next/context.ts | 100 +++++++++ src/next/index.ts | 5 + src/next/mutators.ts | 11 + src/next/mutators/IdentifierMutator.ts | 21 ++ src/next/mutators/ImportSpecifierMutator.ts | 15 ++ .../mutators/InterfaceDeclararionMutator.ts | 35 +++ src/next/mutators/Mutator.ts | 35 +++ src/next/options.ts | 17 ++ src/next/transform.ts | 204 ++++++++++++++++++ tslint.json | 5 +- yarn.lock | 77 ++++++- 13 files changed, 551 insertions(+), 8 deletions(-) create mode 100644 src/next/bus.ts create mode 100644 src/next/context.ts create mode 100644 src/next/index.ts create mode 100644 src/next/mutators.ts create mode 100644 src/next/mutators/IdentifierMutator.ts create mode 100644 src/next/mutators/ImportSpecifierMutator.ts create mode 100644 src/next/mutators/InterfaceDeclararionMutator.ts create mode 100644 src/next/mutators/Mutator.ts create mode 100644 src/next/options.ts create mode 100644 src/next/transform.ts diff --git a/package.json b/package.json index f1b4150..33a002e 100644 --- a/package.json +++ b/package.json @@ -21,13 +21,15 @@ "log-symbols": "^1.0.2", "node-status": "^1.0.0", "ora": "^1.1.0", + "rimraf": "^2.6.1", "ts-type-info": "^6.2.2", - "typescript": "Microsoft/TypeScript#6c122bcf16c329a21da04d7b5256f20ecc0bbd1d" + "typescript": "next" }, "devDependencies": { "@types/commander": "^2.3.31", "@types/escodegen": "^0.0.6", "@types/esprima": "^2.1.33", - "@types/node": "^7.0.2" + "@types/node": "^7.0.2", + "@types/rimraf": "^0.0.28" } } diff --git a/src/next/bus.ts b/src/next/bus.ts new file mode 100644 index 0000000..602cfbd --- /dev/null +++ b/src/next/bus.ts @@ -0,0 +1,28 @@ +import * as EventEmitter from 'events'; + +export const events = { + START: Symbol('start'), + END: Symbol('end'), + DIAGNOSTICS: Symbol('ts.diagnostics'), + DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'), + DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'), + DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'), + DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'), + DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'), + DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'), + TRANSFORM_START: Symbol('transform.start'), + TRANSFORM_END: Symbol('transform.end'), + // TRANSFORM_ERROR: Symbol('transform.error'), + WRITE_START: Symbol('write.start'), + WRITE_END: Symbol('write.end'), + WRITE_FILE_START: Symbol('write.file.start'), + WRITE_FILE_END: Symbol('write.file.end'), + // WRITE_ERROR: Symbol('write.error'), + EMIT_START: Symbol('emit.start'), + EMIT_END: Symbol('emit.end'), + // EMIT_ERROR: Symbol('emit.error'), + TEMP_DELETE_START: Symbol('temp.delete.start'), + TEMP_DELETE_END: Symbol('temp.delete.end'), +}; + +export const emitter = new EventEmitter(); diff --git a/src/next/context.ts b/src/next/context.ts new file mode 100644 index 0000000..f9cbf6f --- /dev/null +++ b/src/next/context.ts @@ -0,0 +1,100 @@ +import * as ts from 'typescript'; + +export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock; + +export class MutationContext { + + private _sourceFile: ts.SourceFile; + private _scope: Scope; + private _visited: ts.Node[]; + private _transformationContext: ts.TransformationContext; + + constructor(sf?: ts.SourceFile) { + this._scope = sf; + this._visited = []; + } + + public wasVisited(node: ts.Node): boolean { + if (this._visited.indexOf(node) !== -1) { + return true; + } + + return false; + } + + public addVisited(node: ts.Node, recursive = false): void { + if (!this.wasVisited(node)) { + this._visited.push(node); + } + + if (recursive) { + ts.forEachChild(node, (n: ts.Node) => { + this.addVisited(n, recursive); + }); + } + } + + public removeVisited(node: ts.Node): boolean { + const index = this._visited.indexOf(node); + + if (index !== -1) { + this._visited.splice(index, 1); + return true; + } + + return false; + } + + public setScope(node: ts.Node): void { + this.scope = node; + } + + public setTransformationContext(transformationContext: ts.TransformationContext): void { + this.transformationContext = transformationContext; + } + + public setSourceFile(sourceFile: ts.Node): void { + this.sourceFile = sourceFile as ts.SourceFile; + } + + get transformationContext() { + return this._transformationContext; + } + + set transformationContext(transformationContext: ts.TransformationContext) { + this._transformationContext = transformationContext; + } + + get visited() { + return this._visited; + } + + get scope() { + return this._scope; + } + + set scope(node: ts.Node) { + switch (node.kind) { + case ts.SyntaxKind.SourceFile: + this._sourceFile = node as ts.SourceFile; + case ts.SyntaxKind.Block: + case ts.SyntaxKind.ModuleBlock: + case ts.SyntaxKind.CaseBlock: + this._scope = node as Scope; + break; + default: + // throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`); + } + } + + get sourceFile() { + return this._sourceFile; + } + + set sourceFile(sourceFile: ts.SourceFile) { + if (sourceFile.kind === ts.SyntaxKind.SourceFile) { + this._sourceFile = sourceFile; + } + } + +} diff --git a/src/next/index.ts b/src/next/index.ts new file mode 100644 index 0000000..4e90cce --- /dev/null +++ b/src/next/index.ts @@ -0,0 +1,5 @@ +export * from './bus'; +export * from './context'; +export * from './mutators'; +export * from './options'; +export * from './transform'; diff --git a/src/next/mutators.ts b/src/next/mutators.ts new file mode 100644 index 0000000..975aa67 --- /dev/null +++ b/src/next/mutators.ts @@ -0,0 +1,11 @@ +import { Mutator } from './mutators/Mutator'; + +import { IdentifierMutator } from './mutators/IdentifierMutator'; +import { ImportSpecifierMutator } from './mutators/ImportSpecifierMutator'; +import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator'; + +export const mutators: Mutator[] = [ + new IdentifierMutator(), + new ImportSpecifierMutator(), + new InterfaceDeclarationMutator() +]; diff --git a/src/next/mutators/IdentifierMutator.ts b/src/next/mutators/IdentifierMutator.ts new file mode 100644 index 0000000..93f2be1 --- /dev/null +++ b/src/next/mutators/IdentifierMutator.ts @@ -0,0 +1,21 @@ +import * as ts from 'typescript'; +import { Mutator } from './Mutator'; +import { MutationContext } from '../context' + +export class IdentifierMutator extends Mutator { + + protected kind = ts.SyntaxKind.Identifier; + + public mutate(node: ts.Identifier, context: MutationContext): ts.Node { + // console.log(node.getText()); + // console.log(node.modifiers); + // console.log(node.originalKeywordKind); + // console.log(ts.NodeFlags[node.flags]); + + // const flags = ts.getCombinedModifierFlags(node); + // console.log(flags); + + return node; + } + +} diff --git a/src/next/mutators/ImportSpecifierMutator.ts b/src/next/mutators/ImportSpecifierMutator.ts new file mode 100644 index 0000000..4a6d0e2 --- /dev/null +++ b/src/next/mutators/ImportSpecifierMutator.ts @@ -0,0 +1,15 @@ +import * as ts from 'typescript'; +import { Mutator } from './Mutator'; +import { MutationContext } from '../context' + +export class ImportSpecifierMutator extends Mutator { + + protected kind = ts.SyntaxKind.ImportSpecifier; + + public mutate(node: ts.ImportSpecifier, context: MutationContext): ts.Node { + // const flags = ts.getCombinedModifierFlags(node); + // console.log(flags); + return node; + } + +} diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/next/mutators/InterfaceDeclararionMutator.ts new file mode 100644 index 0000000..7256a13 --- /dev/null +++ b/src/next/mutators/InterfaceDeclararionMutator.ts @@ -0,0 +1,35 @@ +import * as ts from 'typescript'; +import { Mutator } from './Mutator'; +import { MutationContext } from '../context' + +export class InterfaceDeclarationMutator extends Mutator { + + protected kind = ts.SyntaxKind.InterfaceDeclaration; + + public mutate(node: ts.InterfaceDeclaration, context: MutationContext): ts.Node { + const substitution = ts.createVariableStatement( + node.modifiers, + ts.createVariableDeclarationList( + [ + ts.createVariableDeclaration( + node.name, + undefined, + ts.createCall( + ts.createIdentifier('Symbol'), + undefined, + [ + ts.createLiteral(node.name) + ] + ) + ) + ], + ts.NodeFlags.Const + ) + ); + + context.addVisited(substitution, true); + + return substitution; + } + +} diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts new file mode 100644 index 0000000..263d779 --- /dev/null +++ b/src/next/mutators/Mutator.ts @@ -0,0 +1,35 @@ +import * as ts from 'typescript'; +import { MutationContext } from '../context'; +const self = Mutator; + +export abstract class Mutator { + + protected abstract kind: ts.SyntaxKind | ts.SyntaxKind[]; + + protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node; + + public mutateNode(node: ts.Node, context: MutationContext): ts.Node { + if (!this.shouldMutate(node.kind)) { + return node; + } + + return this.mutate(node, context); + } + + public getKind(): ts.SyntaxKind[] { + if (Array.isArray(this.kind)) { + return this.kind; + } + + return [this.kind]; + } + + public shouldMutate(kind: ts.SyntaxKind): boolean { + if (this.getKind().indexOf(kind) !== -1) { + return true; + } + + return false; + } + +} diff --git a/src/next/options.ts b/src/next/options.ts new file mode 100644 index 0000000..cba0e41 --- /dev/null +++ b/src/next/options.ts @@ -0,0 +1,17 @@ +import * as ts from 'typescript'; + +export interface Options { + compilerOptions?: ts.CompilerOptions; + keepTempFiles?: boolean; + tempFolderName?: string; +} + +export const defaultOptions: Options = { + compilerOptions: { + skipLibCheck: true, + module: ts.ModuleKind.ES2015, + target: ts.ScriptTarget.ES2015 + }, + keepTempFiles: true, + tempFolderName: '.tsr' +}; diff --git a/src/next/transform.ts b/src/next/transform.ts new file mode 100644 index 0000000..0f035bb --- /dev/null +++ b/src/next/transform.ts @@ -0,0 +1,204 @@ +import * as path from 'path'; +import * as rimraf from 'rimraf'; +import * as ts from 'typescript'; +import * as bus from './bus'; +import { MutationContext } from './context'; +import { mutators } from './mutators'; +import { Options, defaultOptions } from './options'; + +const DEBUG = true; + +export function transform(entryFile: string, options?: Options): void { + options = getOptions(options); + bus.emitter.emit(bus.events.START, { entryFile, options }); + + const basePath = path.dirname(entryFile); + const host = ts.createCompilerHost(options.compilerOptions); + const program = ts.createProgram([entryFile], options.compilerOptions, host); + + const diagnostics: ts.Diagnostic[] = []; + + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + } + + if (!check(diagnostics)) { + bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); + } + + const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); + + bus.emitter.emit(bus.events.TRANSFORM_START, { sourceFiles }); + const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); + bus.emitter.emit(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); + + if (!check(result.diagnostics)) { + bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); + } + + const printerOptions: ts.PrinterOptions = { + target: options.compilerOptions.target, + removeComments: false + }; + + const printHandlers: ts.PrintHandlers = { + substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node { + return node; + } + }; + + bus.emitter.emit(bus.events.WRITE_START, { count: result.transformed.length }); + const printer = ts.createPrinter(printerOptions, printHandlers); + + let count = 0; + for (let transformed of result.transformed) { + count++; + const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); + const source = printer.printFile(transformed); + bus.emitter.emit(bus.events.WRITE_FILE_START, { location, transformed, source }); + ts.sys.writeFile(location, source); + bus.emitter.emit(bus.events.WRITE_FILE_END, { location, transformed, source }); + } + + bus.emitter.emit(bus.events.WRITE_END, { count }); + result.dispose(); + + emit(entryFile, options); + + if (!options.keepTempFiles) { + const tempPath = getTempPath(basePath, options.tempFolderName); + bus.emitter.emit(bus.events.TEMP_DELETE_START, { tempPath }); + rimraf.sync(getTempPath(basePath, options.tempFolderName)); + bus.emitter.emit(bus.events.TEMP_DELETE_END, { tempPath }); + } + + bus.emitter.emit(bus.events.END, { entryFile, options }); +} + +export function emit(entryFile: string, options: Options) { + const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); + bus.emitter.emit(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); + + options.compilerOptions.outDir = path.dirname(entryFile); + + const host = ts.createCompilerHost(options.compilerOptions); + const program = ts.createProgram([tempEntryFile], options.compilerOptions, host); + + const diagnostics: ts.Diagnostic[] = []; + + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + } + + + if (!check(diagnostics)) { + bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); + bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); + } + + const emitResult = program.emit(); + + if (!check(emitResult.diagnostics)) { + bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); + bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); + } + + bus.emitter.emit(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); +} + +function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.setTransformationContext(tc); + mc.setSourceFile(node); + mc.setScope(node); + + return node; +} + +function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.addVisited(node); + + return node; +} + +function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + const mutationContext = new MutationContext(); + + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + node = onBeforeVisit(node, mutationContext, context); + + if (DEBUG && !mutationContext.wasVisited(node)) { + const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; + console.log(`Scope: ${scope}`); + } + + for (let mutator of mutators) { + node = mutator.mutateNode(node, mutationContext); + mutationContext.addVisited(node); + } + + if (DEBUG && node.parent) { + console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); + console.log(`File: ${mutationContext.sourceFile.fileName}`); + console.log('<============================================'); + console.log(node.getText()); + console.log('============================================>'); + console.log('\n\n'); + } + + node = onAfterVisit(node, mutationContext, context); + + return ts.visitEachChild(node, visitor, context); + }; + + return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); +} + +function getOptions(options: Options = {}): Options { + const opts = Object.assign({}, defaultOptions, options); + opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {}); + return opts; +} + +function getRootNames(rootNames: string | string[]): string[] { + if (Array.isArray(rootNames)) { + return rootNames; + } + + return [rootNames]; +} + +function getTempPath(basePath: string, tempFolderName: string): string { + return path.join(basePath, tempFolderName); +} + +function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { + const pathFromBase = path.dirname(file.replace(basePath, '')); + const tempPath = getTempPath(basePath, tempFolderName); + const fileName = path.basename(file); + + return path.join(tempPath, pathFromBase, fileName); +} + +function check(diagnostics: ts.Diagnostic[]): boolean { + if (diagnostics && diagnostics.length > 0) { + bus.emitter.emit(bus.events.DIAGNOSTICS, { diagnostics }); + console.error(ts.formatDiagnostics(diagnostics, { + getCurrentDirectory: () => ts.sys.getCurrentDirectory(), + getNewLine: () => ts.sys.newLine, + getCanonicalFileName: (f: string) => f + })); + return false; + } + + return true; +} diff --git a/tslint.json b/tslint.json index 76f8b64..94db9d4 100644 --- a/tslint.json +++ b/tslint.json @@ -18,7 +18,10 @@ "no-consecutive-blank-lines": false, "interface-over-type-literal": false, "prefer-const": false, - "no-var-requires": false + "no-var-requires": false, + "array-type": false, + "trailing-comma": false, + "variable-name": false }, "jsRules": { diff --git a/yarn.lock b/yarn.lock index 00a3d3b..59e9730 100644 --- a/yarn.lock +++ b/yarn.lock @@ -36,6 +36,10 @@ dependencies: "@types/node" "*" +"@types/rimraf@^0.0.28": + version "0.0.28" + resolved "https://registry.yarnpkg.com/@types/rimraf/-/rimraf-0.0.28.tgz#5562519bc7963caca8abf7f128cae3b594d41d06" + ansi-regex@^2.0.0: version "2.1.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df" @@ -44,6 +48,17 @@ ansi-styles@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe" +balanced-match@^0.4.1: + version "0.4.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-0.4.2.tgz#cb3f3e3c732dc0f01ee70b403f302e61d7709838" + +brace-expansion@^1.0.0: + version "1.1.6" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.6.tgz#7197d7eaa9b87e648390ea61fc66c84427420df9" + dependencies: + balanced-match "^0.4.1" + concat-map "0.0.1" + chalk@^1.0.0, chalk@^1.1.1, chalk@^1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98" @@ -94,6 +109,10 @@ commander@^2.9.0: dependencies: graceful-readlink ">= 1.0.0" +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + escape-string-regexp@^1.0.2: version "1.0.5" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" @@ -106,6 +125,21 @@ flow-runtime@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/flow-runtime/-/flow-runtime-0.2.1.tgz#f9a9695b9f9c8b50a8c7f96f25af8565876bf3d7" +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + +glob@^7.0.5: + version "7.1.1" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8" + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.2" + once "^1.3.0" + path-is-absolute "^1.0.0" + "graceful-readlink@>= 1.0.0": version "1.0.1" resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725" @@ -116,7 +150,14 @@ has-ansi@^2.0.0: dependencies: ansi-regex "^2.0.0" -inherits@^2.0.1: +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2, inherits@^2.0.1: version "2.0.3" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de" @@ -130,6 +171,12 @@ mimic-fn@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.1.0.tgz#e667783d92e89dbd342818b5230b9d62a672ad18" +minimatch@^3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774" + dependencies: + brace-expansion "^1.0.0" + node-status@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/node-status/-/node-status-1.0.0.tgz#7906a7c47a6587d03496bf74ec634abaa03f8e80" @@ -139,6 +186,12 @@ node-status@^1.0.0: cli-spinners "0.2.0" colors "1.1.2" +once@^1.3.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + dependencies: + wrappy "1" + onetime@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789" @@ -162,6 +215,10 @@ os-tmpdir@~1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + restore-cursor@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541" @@ -176,6 +233,12 @@ restore-cursor@^2.0.0: onetime "^2.0.0" signal-exit "^3.0.2" +rimraf@^2.6.1: + version "2.6.1" + resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d" + dependencies: + glob "^7.0.5" + signal-exit@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d" @@ -204,10 +267,14 @@ ts-type-info@^6.2.2: tmp "0.0.28" typescript "^2.1.4" -typescript@Microsoft/TypeScript#6c122bcf16c329a21da04d7b5256f20ecc0bbd1d: - version "2.1.0" - resolved "https://codeload.github.com/Microsoft/TypeScript/tar.gz/6c122bcf16c329a21da04d7b5256f20ecc0bbd1d" - typescript@^2.1.4: version "2.1.5" resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.1.5.tgz#6fe9479e00e01855247cea216e7561bafcdbcd4a" + +typescript@next: + version "2.3.0-dev.20170306" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.3.0-dev.20170306.tgz#1b2af5681473d13950ebc7319f120c607b6b34b4" + +wrappy@1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" From 0cb7a9b592123de19d7176370931dec724c685ab Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:34:25 +0100 Subject: [PATCH 03/26] Package and linter changes. --- package.json | 4 ++-- tslint.json | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/package.json b/package.json index 33a002e..7c0f1fa 100644 --- a/package.json +++ b/package.json @@ -13,8 +13,6 @@ "build": "tsc --rootDir src --outDir dist --module CommonJS --target es6 --skipLibCheck" }, "dependencies": { - "@types/chalk": "^0.4.31", - "@types/ora": "^0.3.31", "chalk": "^1.1.3", "commander": "^2.9.0", "flow-runtime": "^0.2.1", @@ -26,10 +24,12 @@ "typescript": "next" }, "devDependencies": { + "@types/chalk": "^0.4.31", "@types/commander": "^2.3.31", "@types/escodegen": "^0.0.6", "@types/esprima": "^2.1.33", "@types/node": "^7.0.2", + "@types/ora": "^0.3.31", "@types/rimraf": "^0.0.28" } } diff --git a/tslint.json b/tslint.json index 94db9d4..4b8c6d7 100644 --- a/tslint.json +++ b/tslint.json @@ -21,7 +21,8 @@ "no-var-requires": false, "array-type": false, "trailing-comma": false, - "variable-name": false + "variable-name": false, + "no-conditional-assignment": false }, "jsRules": { From e01141a0089583cd084c9dbe945b8c85ec3534ca Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:34:53 +0100 Subject: [PATCH 04/26] Added util for common actions, where no context is needed. --- src/next/util.ts | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 src/next/util.ts diff --git a/src/next/util.ts b/src/next/util.ts new file mode 100644 index 0000000..b95f859 --- /dev/null +++ b/src/next/util.ts @@ -0,0 +1,37 @@ +import * as ts from 'typescript'; + +export function setParent(node: ts.Node): void { + if (!node) return; + ts.forEachChild(node, n => { + n.parent = node; + setParent(n); + }); +} + +export function getScope(node: ts.Node): ts.Node { + if (node.kind === ts.SyntaxKind.SourceFile) { + return node; + } + + if (this.isScope(node.kind)) { + return node; + } + + return this.getScope(node.parent); +} + +export function isScope(kind: ts.SyntaxKind): boolean { + switch (kind) { + case ts.SyntaxKind.SourceFile: + case ts.SyntaxKind.Block: + case ts.SyntaxKind.ModuleBlock: + case ts.SyntaxKind.CaseBlock: + return true; + default: + return false; + } +} + +export function isKind(node: ts.Node, kind: ts.SyntaxKind): boolean { + return node.kind === kind; +} From 03f65e6aef94e63d4c73b3265a0dfc5eb13e151c Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:35:31 +0100 Subject: [PATCH 05/26] Generator for recurring node structures. --- src/next/generator.ts | 79 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 src/next/generator.ts diff --git a/src/next/generator.ts b/src/next/generator.ts new file mode 100644 index 0000000..69e4c62 --- /dev/null +++ b/src/next/generator.ts @@ -0,0 +1,79 @@ +import * as ts from 'typescript'; + +export const LIB = 't'; + +export function typeDefinition(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration { + return ts.createVariableDeclaration(name, undefined, typeAssertion(type)); +} + +export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression { + if (!type) { + return null; + } + + if (typeof type === 'string') { + return propertyAccessCall(LIB, type as string); + } + + type = type as ts.TypeNode; + + switch (type.kind) { + case ts.SyntaxKind.BooleanKeyword: + case ts.SyntaxKind.NumberKeyword: + case ts.SyntaxKind.StringKeyword: + case ts.SyntaxKind.AnyKeyword: + { + return propertyAccessCall(LIB, type.getText()); + } + case ts.SyntaxKind.ArrayType: + { + const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode; + const callExpression = propertyAccessCall(LIB, 'array', typeAssertion(typeNode)); + return callExpression; + } + case ts.SyntaxKind.TypeReference: + { + const typeRef = type as ts.TypeReferenceNode; + const typeName = typeRef.typeName.getText(); + const args: ts.CallExpression[] = []; + let callExpression: ts.CallExpression; + + if (typeRef.typeArguments) { + for (const arg of typeRef.typeArguments) { + args.push(typeAssertion(arg)); + } + } + + if (typeName === 'Array' || typeName === 'array') { + callExpression = propertyAccessCall(LIB, 'array', args); + } else { + callExpression = propertyAccessCall(LIB, 'ref', ts.createIdentifier(typeName)); + } + + return callExpression; + } + case ts.SyntaxKind.TupleType: + { + const typeRef = type as ts.TupleTypeNode; + const args: ts.CallExpression[] = []; + + for (const arg of typeRef.elementTypes) { + args.push(typeAssertion(arg)); + } + + return propertyAccessCall(LIB, 'tuple', args); + } + default: + { + return propertyAccessCall(LIB, 'any'); + } + } +} + +export function propertyAccessCall(id: string | ts.Expression, prop: string | ts.Identifier, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression { + id = typeof id === 'string' ? ts.createIdentifier(id) : id; + args = Array.isArray(args) ? args : [args]; + types = Array.isArray(types) ? types : [types]; + + return ts.createCall(ts.createPropertyAccess(id, prop), types, args); +} From 37d7b68b8c32ed9119cbe05723a2f4b438457095 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:36:12 +0100 Subject: [PATCH 06/26] Added and removed mutators. Changes to base class. --- src/next/mutators/IdentifierMutator.ts | 21 ----- src/next/mutators/ImportSpecifierMutator.ts | 15 ---- .../mutators/InterfaceDeclararionMutator.ts | 2 +- src/next/mutators/Mutator.ts | 19 ++--- .../VariableDeclarationListMutator.ts | 83 +++++++++++++++++++ 5 files changed, 93 insertions(+), 47 deletions(-) delete mode 100644 src/next/mutators/IdentifierMutator.ts delete mode 100644 src/next/mutators/ImportSpecifierMutator.ts create mode 100644 src/next/mutators/VariableDeclarationListMutator.ts diff --git a/src/next/mutators/IdentifierMutator.ts b/src/next/mutators/IdentifierMutator.ts deleted file mode 100644 index 93f2be1..0000000 --- a/src/next/mutators/IdentifierMutator.ts +++ /dev/null @@ -1,21 +0,0 @@ -import * as ts from 'typescript'; -import { Mutator } from './Mutator'; -import { MutationContext } from '../context' - -export class IdentifierMutator extends Mutator { - - protected kind = ts.SyntaxKind.Identifier; - - public mutate(node: ts.Identifier, context: MutationContext): ts.Node { - // console.log(node.getText()); - // console.log(node.modifiers); - // console.log(node.originalKeywordKind); - // console.log(ts.NodeFlags[node.flags]); - - // const flags = ts.getCombinedModifierFlags(node); - // console.log(flags); - - return node; - } - -} diff --git a/src/next/mutators/ImportSpecifierMutator.ts b/src/next/mutators/ImportSpecifierMutator.ts deleted file mode 100644 index 4a6d0e2..0000000 --- a/src/next/mutators/ImportSpecifierMutator.ts +++ /dev/null @@ -1,15 +0,0 @@ -import * as ts from 'typescript'; -import { Mutator } from './Mutator'; -import { MutationContext } from '../context' - -export class ImportSpecifierMutator extends Mutator { - - protected kind = ts.SyntaxKind.ImportSpecifier; - - public mutate(node: ts.ImportSpecifier, context: MutationContext): ts.Node { - // const flags = ts.getCombinedModifierFlags(node); - // console.log(flags); - return node; - } - -} diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/next/mutators/InterfaceDeclararionMutator.ts index 7256a13..0d73e73 100644 --- a/src/next/mutators/InterfaceDeclararionMutator.ts +++ b/src/next/mutators/InterfaceDeclararionMutator.ts @@ -1,6 +1,6 @@ import * as ts from 'typescript'; import { Mutator } from './Mutator'; -import { MutationContext } from '../context' +import { MutationContext } from '../context'; export class InterfaceDeclarationMutator extends Mutator { diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts index 263d779..a5454a4 100644 --- a/src/next/mutators/Mutator.ts +++ b/src/next/mutators/Mutator.ts @@ -9,11 +9,18 @@ export abstract class Mutator { protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node; public mutateNode(node: ts.Node, context: MutationContext): ts.Node { - if (!this.shouldMutate(node.kind)) { + if (this.getKind().indexOf(node.kind) === -1) { return node; } - return this.mutate(node, context); + if (context.wasVisited(node)) { + return node; + } + + const substitution = this.mutate(node, context); + context.addVisited(substitution); + + return substitution; } public getKind(): ts.SyntaxKind[] { @@ -24,12 +31,4 @@ export abstract class Mutator { return [this.kind]; } - public shouldMutate(kind: ts.SyntaxKind): boolean { - if (this.getKind().indexOf(kind) !== -1) { - return true; - } - - return false; - } - } diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/next/mutators/VariableDeclarationListMutator.ts new file mode 100644 index 0000000..32ba992 --- /dev/null +++ b/src/next/mutators/VariableDeclarationListMutator.ts @@ -0,0 +1,83 @@ +import * as ts from 'typescript'; +import * as generator from '../generator'; +import { Mutator } from './Mutator'; +import { MutationContext } from '../context'; + +export class VariableDeclarationListMutator extends Mutator { + + protected kind = ts.SyntaxKind.VariableDeclarationList; + + public mutate(node: ts.VariableDeclarationList, context: MutationContext): ts.Node { + if (!node.declarations) { + return node; + } + + const declarations: ts.VariableDeclaration[] = []; + + for (const declaration of node.declarations) { + const transformed = this.transformDeclaration(declaration, context); + transformed.forEach(n => context.addVisited(n, true)); + declarations.push(...transformed); + } + + return ts.updateVariableDeclarationList(node, declarations); + } + + private transformDeclaration(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] { + if (context.wasVisited(node)) { + return [node]; + } + + const isConst = node.parent && node.parent.flags === ts.NodeFlags.Const; + + if (!node.type) { + if (isConst) { + return this.transformUntypedConstDeclaration(node); + } + + return this.transformUntypedLetDeclaration(node); + } + + if (isConst) { + return this.transformConstDeclaration(node); + } + + return this.transformLetDeclaration(node); + } + + private transformLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + const nodeName = node.name.getText(); + const typeDefinition = generator.typeDefinition(`_${nodeName}Type`, node.type); + + if (!node.initializer) { + return [typeDefinition, node]; + } + + const initializer = generator.propertyAccessCall(`_${nodeName}Type`, 'assert', node.initializer); + const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); + + return [typeDefinition, assignment]; + } + + private transformConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + const nodeName = node.name.getText(); + const typeCalls = generator.typeAssertion(node.type); + + const initializer = ts.createCall( + ts.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer], + ); + + const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); + + return [assignment]; + } + + private transformUntypedLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + return [node]; + } + + private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + return [node]; + } + +} From 6fa626c498c91e298cb3e482cb7acd8cd5669f4f Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:36:32 +0100 Subject: [PATCH 07/26] Moved common actions to util. Fixes. --- src/next/context.ts | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/next/context.ts b/src/next/context.ts index f9cbf6f..a0ce6d1 100644 --- a/src/next/context.ts +++ b/src/next/context.ts @@ -1,4 +1,5 @@ import * as ts from 'typescript'; +import * as util from './util'; export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock; @@ -83,7 +84,7 @@ export class MutationContext { this._scope = node as Scope; break; default: - // throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`); + throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`); } } @@ -92,9 +93,11 @@ export class MutationContext { } set sourceFile(sourceFile: ts.SourceFile) { - if (sourceFile.kind === ts.SyntaxKind.SourceFile) { - this._sourceFile = sourceFile; + if (!util.isKind(sourceFile, ts.SyntaxKind.SourceFile)) { + throw new Error(`Attemt to set invalid node as SourceFile, got ${ts.SyntaxKind[sourceFile.kind]}.`); } + + this._sourceFile = sourceFile; } } From d6f692535c4f28de5ed5aeab58481d9f808e4148 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:37:05 +0100 Subject: [PATCH 08/26] Change to latest mutator instances. --- src/next/mutators.ts | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/next/mutators.ts b/src/next/mutators.ts index 975aa67..8b0c215 100644 --- a/src/next/mutators.ts +++ b/src/next/mutators.ts @@ -1,11 +1,9 @@ import { Mutator } from './mutators/Mutator'; -import { IdentifierMutator } from './mutators/IdentifierMutator'; -import { ImportSpecifierMutator } from './mutators/ImportSpecifierMutator'; import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator'; +import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator'; export const mutators: Mutator[] = [ - new IdentifierMutator(), - new ImportSpecifierMutator(), - new InterfaceDeclarationMutator() + new InterfaceDeclarationMutator(), + new VariableDeclarationListMutator(), ]; From 4c646aa49f9d2503bb735745fdcb633ce3d5956a Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:38:02 +0100 Subject: [PATCH 09/26] Restore parent nodes. Determine correct scope. Other improvements and fixes. --- src/next/transform.ts | 84 +++++++++++++++++++++++++++---------------- 1 file changed, 54 insertions(+), 30 deletions(-) diff --git a/src/next/transform.ts b/src/next/transform.ts index 0f035bb..a174c25 100644 --- a/src/next/transform.ts +++ b/src/next/transform.ts @@ -1,6 +1,7 @@ import * as path from 'path'; import * as rimraf from 'rimraf'; import * as ts from 'typescript'; +import * as util from './util'; import * as bus from './bus'; import { MutationContext } from './context'; import { mutators } from './mutators'; @@ -10,7 +11,7 @@ const DEBUG = true; export function transform(entryFile: string, options?: Options): void { options = getOptions(options); - bus.emitter.emit(bus.events.START, { entryFile, options }); + notify(bus.events.START, { entryFile, options }); const basePath = path.dirname(entryFile); const host = ts.createCompilerHost(options.compilerOptions); @@ -27,19 +28,19 @@ export function transform(entryFile: string, options?: Options): void { } if (!check(diagnostics)) { - bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); } const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); - bus.emitter.emit(bus.events.TRANSFORM_START, { sourceFiles }); + notify(bus.events.TRANSFORM_START, { sourceFiles }); const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); - bus.emitter.emit(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); + notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); if (!check(result.diagnostics)) { - bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); } const printerOptions: ts.PrinterOptions = { @@ -53,7 +54,7 @@ export function transform(entryFile: string, options?: Options): void { } }; - bus.emitter.emit(bus.events.WRITE_START, { count: result.transformed.length }); + notify(bus.events.WRITE_START, { count: result.transformed.length }); const printer = ts.createPrinter(printerOptions, printHandlers); let count = 0; @@ -61,29 +62,30 @@ export function transform(entryFile: string, options?: Options): void { count++; const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); const source = printer.printFile(transformed); - bus.emitter.emit(bus.events.WRITE_FILE_START, { location, transformed, source }); + notify(bus.events.WRITE_FILE_START, { location, transformed, source }); ts.sys.writeFile(location, source); - bus.emitter.emit(bus.events.WRITE_FILE_END, { location, transformed, source }); + notify(bus.events.WRITE_FILE_END, { location, transformed, source }); } - bus.emitter.emit(bus.events.WRITE_END, { count }); + notify(bus.events.WRITE_END, { count }); + result.dispose(); emit(entryFile, options); if (!options.keepTempFiles) { const tempPath = getTempPath(basePath, options.tempFolderName); - bus.emitter.emit(bus.events.TEMP_DELETE_START, { tempPath }); + notify(bus.events.TEMP_DELETE_START, { tempPath }); rimraf.sync(getTempPath(basePath, options.tempFolderName)); - bus.emitter.emit(bus.events.TEMP_DELETE_END, { tempPath }); + notify(bus.events.TEMP_DELETE_END, { tempPath }); } - bus.emitter.emit(bus.events.END, { entryFile, options }); + notify(bus.events.END, { entryFile, options }); } export function emit(entryFile: string, options: Options) { const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); - bus.emitter.emit(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); + notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); options.compilerOptions.outDir = path.dirname(entryFile); @@ -102,31 +104,33 @@ export function emit(entryFile: string, options: Options) { if (!check(diagnostics)) { - bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); - bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); } const emitResult = program.emit(); if (!check(emitResult.diagnostics)) { - bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); - bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); } - bus.emitter.emit(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); + notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); } function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + if (util.isKind(node, ts.SyntaxKind.SourceFile)) { + mc.setSourceFile(node); + } + mc.setTransformationContext(tc); - mc.setSourceFile(node); - mc.setScope(node); + mc.setScope(util.getScope(node)); return node; } function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { mc.addVisited(node); - return node; } @@ -134,24 +138,40 @@ function transformer(context: ts.TransformationContext): ts.Transformer<ts.Sourc const mutationContext = new MutationContext(); const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + const parent = node.parent; node = onBeforeVisit(node, mutationContext, context); - if (DEBUG && !mutationContext.wasVisited(node)) { + if (DEBUG) { const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; + console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`) console.log(`Scope: ${scope}`); + console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); + console.log(`File: ${mutationContext.sourceFile.fileName}`); } for (let mutator of mutators) { node = mutator.mutateNode(node, mutationContext); - mutationContext.addVisited(node); } - if (DEBUG && node.parent) { - console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); - console.log(`File: ${mutationContext.sourceFile.fileName}`); + node.parent = parent; + util.setParent(node); + + if (DEBUG) { console.log('<============================================'); - console.log(node.getText()); + if (node.parent) { + if (node.flags === ts.NodeFlags.Synthesized) { + console.log('Cannot get text of synthesized node.'); + } else { + console.log(node.getText()); + } + } else { + console.log('Parent not set, cannot get text.'); + } console.log('============================================>'); + } + + + if (DEBUG) { console.log('\n\n'); } @@ -191,7 +211,7 @@ function toTempFilePath(file: string, basePath: string, tempFolderName: string): function check(diagnostics: ts.Diagnostic[]): boolean { if (diagnostics && diagnostics.length > 0) { - bus.emitter.emit(bus.events.DIAGNOSTICS, { diagnostics }); + notify(bus.events.DIAGNOSTICS, { diagnostics }); console.error(ts.formatDiagnostics(diagnostics, { getCurrentDirectory: () => ts.sys.getCurrentDirectory(), getNewLine: () => ts.sys.newLine, @@ -202,3 +222,7 @@ function check(diagnostics: ts.Diagnostic[]): boolean { return true; } + +function notify(event: string | symbol, ...args: any[]): boolean { + return bus.emitter.emit(event, args); +} From 4c39f47a4135eee16dd803f7d0e522368070d928 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:38:44 +0100 Subject: [PATCH 10/26] Package exports. --- src/next/index.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/next/index.ts b/src/next/index.ts index 4e90cce..85a7872 100644 --- a/src/next/index.ts +++ b/src/next/index.ts @@ -1,4 +1,9 @@ -export * from './bus'; +import * as b from './bus'; +export const bus = b; + +import * as u from './util'; +export const util = u; + export * from './context'; export * from './mutators'; export * from './options'; From 7fb159e8f53e8d226aab4191472972bf2b208975 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 21:39:29 +0100 Subject: [PATCH 11/26] Temporary test files. --- src/test/config-2017-03-10_17-40-38-656.ts | 3 + src/test/factory.ts | 87 ++++++++++++++++ src/test/source.js | 2 + src/test/source.ts | 5 + src/test/test.ts | 17 ++++ src/test/transformer.ts | 19 ++++ src/test/v1.ts | 38 +++++++ src/test/v2/.tsr/source.ts | 11 +++ src/test/v2/.tsr/source2.ts | 2 + src/test/v2/.tsr/source3.ts | 1 + src/test/v2/.tsr/source4.ts | 10 ++ src/test/v2/source.js | 11 +++ src/test/v2/source.ts | 15 +++ src/test/v2/source2.js | 2 + src/test/v2/source2.ts | 5 + src/test/v2/source3.js | 1 + src/test/v2/source3.ts | 1 + src/test/v2/source4.js | 7 ++ src/test/v2/source4.ts | 13 +++ src/test/v2/test.ts | 6 ++ src/test/v2/test2.ts | 4 + src/test/v2/transform.old.ts | 110 +++++++++++++++++++++ 22 files changed, 370 insertions(+) create mode 100644 src/test/config-2017-03-10_17-40-38-656.ts create mode 100644 src/test/factory.ts create mode 100644 src/test/source.js create mode 100644 src/test/source.ts create mode 100644 src/test/test.ts create mode 100644 src/test/transformer.ts create mode 100644 src/test/v1.ts create mode 100644 src/test/v2/.tsr/source.ts create mode 100644 src/test/v2/.tsr/source2.ts create mode 100644 src/test/v2/.tsr/source3.ts create mode 100644 src/test/v2/.tsr/source4.ts create mode 100644 src/test/v2/source.js create mode 100644 src/test/v2/source.ts create mode 100644 src/test/v2/source2.js create mode 100644 src/test/v2/source2.ts create mode 100644 src/test/v2/source3.js create mode 100644 src/test/v2/source3.ts create mode 100644 src/test/v2/source4.js create mode 100644 src/test/v2/source4.ts create mode 100644 src/test/v2/test.ts create mode 100644 src/test/v2/test2.ts create mode 100644 src/test/v2/transform.old.ts diff --git a/src/test/config-2017-03-10_17-40-38-656.ts b/src/test/config-2017-03-10_17-40-38-656.ts new file mode 100644 index 0000000..c5dbbef --- /dev/null +++ b/src/test/config-2017-03-10_17-40-38-656.ts @@ -0,0 +1,3 @@ +export interface TsRuntimeConfig { + +} diff --git a/src/test/factory.ts b/src/test/factory.ts new file mode 100644 index 0000000..7d36e74 --- /dev/null +++ b/src/test/factory.ts @@ -0,0 +1,87 @@ +import * as path from 'path'; +import * as ts from 'typescript'; + +function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + return visitEachChildFirst(node, visitor, context); + }; + + const transformer: ts.Transformer<ts.SourceFile> = (sf: ts.SourceFile) => ts.visitNode(sf, visitor); + + return transformer; +} + +function transform(node: ts.Node, context: ts.TransformationContext): ts.Node { + console.log('<--------------------'); + console.log(node.getText()); + console.log('-------------------->'); + console.log(''); + + if (node === null) return null; + + if (node.kind === ts.SyntaxKind.FunctionDeclaration) { + return null; + } + + return node; +} + +function visitEachChild(node: ts.Node, visitor: ts.Visitor, context: ts.TransformationContext): ts.Node { + node = transform(node, context); + if (node === null) return null; + return ts.visitEachChild(node, visitor, context); +} + +function visitEachChildFirst(node: ts.Node, visitor: ts.Visitor, context: ts.TransformationContext): ts.Node { + node = ts.visitEachChild(node, visitor, context); + return transform(node, context); +} + +function check(diagnostics: ts.Diagnostic[]): boolean { + if (diagnostics && diagnostics.length > 0) { + console.error(ts.formatDiagnostics(diagnostics, { + getCurrentDirectory: () => ts.sys.getCurrentDirectory(), + getNewLine: () => ts.sys.newLine, + getCanonicalFileName: (f: string) => f + })); + return false; + } + + return true; +} + +function main() { + const options: ts.CompilerOptions = { + skipLibCheck: true, + experimentalDecorators: true, + noEmitOnError: false, + }; + + const beforeTransforms = [transformer]; + const afterTransforms: ts.TransformerFactory<ts.SourceFile>[] = []; + + const compilerHost = ts.createCompilerHost(options); + const program = ts.createProgram([path.join(__dirname, './source.ts')], options, compilerHost); + + const diags: ts.Diagnostic[] = []; + + diags.push(...program.getOptionsDiagnostics()); + diags.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diags.push(...program.getSyntacticDiagnostics(sourceFile)); + diags.push(...program.getSemanticDiagnostics(sourceFile)); + } + + console.log('check before emit'); + check(diags); + + const { diagnostics } = program.emit( + undefined, undefined, undefined, undefined, { before: beforeTransforms, after: afterTransforms } + ); + + console.log('check after emit'); + check(diagnostics); +} + +main(); diff --git a/src/test/source.js b/src/test/source.js new file mode 100644 index 0000000..f0a037a --- /dev/null +++ b/src/test/source.js @@ -0,0 +1,2 @@ +var test = 10; +var test = 11; diff --git a/src/test/source.ts b/src/test/source.ts new file mode 100644 index 0000000..d76d110 --- /dev/null +++ b/src/test/source.ts @@ -0,0 +1,5 @@ +let test: number = 10; +let test: boolean = 11; +function hello(x: number): boolean { + return true; +} diff --git a/src/test/test.ts b/src/test/test.ts new file mode 100644 index 0000000..2d3c7e6 --- /dev/null +++ b/src/test/test.ts @@ -0,0 +1,17 @@ +import * as ts from "typescript"; + +export function runNameofOnFiles(filePaths: string[]) { + const results: { fileName: string; text: string; }[] = []; + const compilerOptions: ts.CompilerOptions = { + strictNullChecks: true, + target: ts.ScriptTarget.ES2017 + }; + const transformers: ts.CustomTransformers = { + before: [nameofTransformFactory], + after: [] + }; + const program = ts.createProgram(filePaths, compilerOptions); + program.emit(undefined, (fileName, text) => results.push({ fileName, text }), undefined, false, transformers); + + return results; +} diff --git a/src/test/transformer.ts b/src/test/transformer.ts new file mode 100644 index 0000000..c77db30 --- /dev/null +++ b/src/test/transformer.ts @@ -0,0 +1,19 @@ +import * as ts from 'typescript'; + +export function transformer(context: ts.TransformationContext): + ts.Transformer<ts.SourceFile> { + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + switch (node.kind) { + case ts.SyntaxKind.Decorator: + // drop on the floor; + return null as any; + default: + return ts.visitEachChild(node, visitor, context); + } + }; + + const transformer: ts.Transformer<ts.SourceFile> = (sf: ts.SourceFile) => + ts.visitNode(sf, visitor); + + return transformer; +} diff --git a/src/test/v1.ts b/src/test/v1.ts new file mode 100644 index 0000000..84263c3 --- /dev/null +++ b/src/test/v1.ts @@ -0,0 +1,38 @@ +import * as ts from 'typescript'; + +function transform(options: ts.CompilerOptions, fileNames: string[], allDiagnostics: ts.Diagnostic[]): any { + const files = new Map<string, string>(); + const program = ts.createProgram(fileNames, options); + + { + const diagnostics = ts.getPreEmitDiagnostics(program); + if (diagnostics.length > 0) { + allDiagnostics.push(...diagnostics); + logDiagnostics(allDiagnostics); + return null; + } + } + + const emitResult = program.emit(undefined); + + if (emitResult.diagnostics.length > 0) { + allDiagnostics.push(...emitResult.diagnostics); + logDiagnostics(allDiagnostics); + return null; + } + + const exitCode = emitResult.emitSkipped ? 1 : 0; + console.log(`Process exiting with code '${exitCode}'.`); + + return emitResult; +} + +function logDiagnostics(allDiagnostics: ts.Diagnostic[]) { + allDiagnostics.forEach(diagnostic => { + let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); + let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'); + console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); + }); +} + +const emitResult = transform({}, ['test1.ts'], []); diff --git a/src/test/v2/.tsr/source.ts b/src/test/v2/.tsr/source.ts new file mode 100644 index 0000000..a435ad7 --- /dev/null +++ b/src/test/v2/.tsr/source.ts @@ -0,0 +1,11 @@ +import { a, TestInterface } from './source2'; +import { bla } from './source3'; +console.log(a); +console.log(bla); +console.log(TestInterface); +class Test implements TestInterface { + public test(): string { + let a = 'hi'; + return a; + } +} diff --git a/src/test/v2/.tsr/source2.ts b/src/test/v2/.tsr/source2.ts new file mode 100644 index 0000000..57e4e57 --- /dev/null +++ b/src/test/v2/.tsr/source2.ts @@ -0,0 +1,2 @@ +export const TestInterface = Symbol("TestInterface"); +export const a = 'hi'; diff --git a/src/test/v2/.tsr/source3.ts b/src/test/v2/.tsr/source3.ts new file mode 100644 index 0000000..c019563 --- /dev/null +++ b/src/test/v2/.tsr/source3.ts @@ -0,0 +1 @@ +export const bla = 'bla'; diff --git a/src/test/v2/.tsr/source4.ts b/src/test/v2/.tsr/source4.ts new file mode 100644 index 0000000..027a7c7 --- /dev/null +++ b/src/test/v2/.tsr/source4.ts @@ -0,0 +1,10 @@ +type TestType = { + name: string; +}; +const a: string = t.string().assert(10); +let _bType = t.array(t.number()), b: number[]; +b = [a]; +function testFunction(t: TestType): string { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); diff --git a/src/test/v2/source.js b/src/test/v2/source.js new file mode 100644 index 0000000..f482f67 --- /dev/null +++ b/src/test/v2/source.js @@ -0,0 +1,11 @@ +import { a, TestInterface } from './source2'; +import { bla } from './source3'; +console.log(a); +console.log(bla); +console.log(TestInterface); +class Test { + test() { + let a = 'hi'; + return a; + } +} diff --git a/src/test/v2/source.ts b/src/test/v2/source.ts new file mode 100644 index 0000000..4a84eb7 --- /dev/null +++ b/src/test/v2/source.ts @@ -0,0 +1,15 @@ +import { a, TestInterface } from './source2'; +import { bla } from './source3'; + +console.log(a); +console.log(bla); +console.log(TestInterface); + +class Test implements TestInterface { + + public test(): string { + let a = 'hi'; + return a; + } + +} diff --git a/src/test/v2/source2.js b/src/test/v2/source2.js new file mode 100644 index 0000000..57e4e57 --- /dev/null +++ b/src/test/v2/source2.js @@ -0,0 +1,2 @@ +export const TestInterface = Symbol("TestInterface"); +export const a = 'hi'; diff --git a/src/test/v2/source2.ts b/src/test/v2/source2.ts new file mode 100644 index 0000000..888f0ea --- /dev/null +++ b/src/test/v2/source2.ts @@ -0,0 +1,5 @@ +export interface TestInterface { + +} + +export const a = 'hi'; diff --git a/src/test/v2/source3.js b/src/test/v2/source3.js new file mode 100644 index 0000000..c019563 --- /dev/null +++ b/src/test/v2/source3.js @@ -0,0 +1 @@ +export const bla = 'bla'; diff --git a/src/test/v2/source3.ts b/src/test/v2/source3.ts new file mode 100644 index 0000000..c019563 --- /dev/null +++ b/src/test/v2/source3.ts @@ -0,0 +1 @@ +export const bla = 'bla'; diff --git a/src/test/v2/source4.js b/src/test/v2/source4.js new file mode 100644 index 0000000..4017790 --- /dev/null +++ b/src/test/v2/source4.js @@ -0,0 +1,7 @@ +const a = t.string().assert(10); +let _bType = t.array(t.number()), b; +b = [a]; +function testFunction(t) { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); diff --git a/src/test/v2/source4.ts b/src/test/v2/source4.ts new file mode 100644 index 0000000..4d5ad9f --- /dev/null +++ b/src/test/v2/source4.ts @@ -0,0 +1,13 @@ +type TestType = { + name: string; +} + +const a: string = 10; +let b: number[]; +b = [a]; + +function testFunction (t: TestType): string { + return 'Hello ' + t.name; +} + +console.log(testFunction({name: 'Alice'})); diff --git a/src/test/v2/test.ts b/src/test/v2/test.ts new file mode 100644 index 0000000..1ce7016 --- /dev/null +++ b/src/test/v2/test.ts @@ -0,0 +1,6 @@ +import * as path from 'path'; +import * as tsr from '../../next/'; + +tsr.transform(path.join(__dirname, './source4.ts'), { + compilerOptions: {} +}); diff --git a/src/test/v2/test2.ts b/src/test/v2/test2.ts new file mode 100644 index 0000000..7c04d03 --- /dev/null +++ b/src/test/v2/test2.ts @@ -0,0 +1,4 @@ +import * as path from 'path'; +import { transform } from './transform2'; + +transform(path.join(__dirname, '../test/v2/source.ts')); diff --git a/src/test/v2/transform.old.ts b/src/test/v2/transform.old.ts new file mode 100644 index 0000000..3e38796 --- /dev/null +++ b/src/test/v2/transform.old.ts @@ -0,0 +1,110 @@ +import * as ts from 'typescript'; +import { bus, messages } from './bus'; +import { Options, defaultOptions } from './options'; +import { Mutator } from './mutators/Mutator'; +import { MutationContext } from './context'; +import { mutators } from './mutators'; + +const DEBUG = true; + +export function transform(files: string | string[], options?: Options): ts.EmitResult { + const compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions); + const opts = Object.assign({}, defaultOptions, options); + opts.compilerOptions = compilerOptions; + + const rootNames = Array.isArray(files) ? files : [files]; + + const compilerHost = ts.createCompilerHost(compilerOptions); + const program = ts.createProgram(rootNames, compilerOptions, compilerHost); + + const diags: ts.Diagnostic[] = []; + + diags.push(...program.getOptionsDiagnostics()); + diags.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diags.push(...program.getSyntacticDiagnostics(sourceFile)); + diags.push(...program.getSemanticDiagnostics(sourceFile)); + } + + check(diags); + + const beforeTransforms: ts.TransformerFactory<ts.SourceFile>[] = [beforeTransformer]; + const afterTransforms: ts.TransformerFactory<ts.SourceFile>[] = [afterTransformer]; + + const emitResult = program.emit( + undefined, undefined, undefined, undefined, + { before: beforeTransforms, after: afterTransforms } + ); + + check(emitResult.diagnostics); + + return emitResult; +} + +function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.setTransformationContext(tc); + mc.setScope(node); + + return node; +} + +function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.addVisited(node); + + return node; +} + +function beforeTransformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + const mutationContext = new MutationContext(); + + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + node = onBeforeVisit(node, mutationContext, context); + + if (DEBUG && !mutationContext.wasVisited(node)) { + const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; + console.log(`Scope: ${scope}`); + } + + for (let mutator of mutators) { + node = mutator.mutateNode(node, mutationContext); + mutationContext.addVisited(node); + } + + if (DEBUG && node.parent) { + console.log(`Kind: ${ts.SyntaxKind[node.kind]}`); + console.log('<==================='); + console.log(node.getText()); + console.log('==================>'); + console.log('\n\n'); + } + + node = onAfterVisit(node, mutationContext, context); + + return ts.visitEachChild(node, visitor, context); + }; + + return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); +} + +function afterTransformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + // const flags = ts.getCombinedModifierFlags(node); + // const str = ts.ModifierFlags[flags]; + // console.log(str); + return ts.visitEachChild(node, visitor, context); + }; + + return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); +} + +function check(diagnostics: ts.Diagnostic[]): void { + if (diagnostics && diagnostics.length > 0) { + bus.emit(messages.TS_COMPILER_DIAGNOSTICS, diagnostics); + console.error(ts.formatDiagnostics(diagnostics, { + getCurrentDirectory: () => ts.sys.getCurrentDirectory(), + getNewLine: () => ts.sys.newLine, + getCanonicalFileName: (f: string) => f + })); + } +} From e28cd0819b9723f5420d428f2e0c1449bd5e5fec Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 22:47:43 +0100 Subject: [PATCH 12/26] Util fixes and additions. --- src/next/util.ts | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/src/next/util.ts b/src/next/util.ts index b95f859..1c6c17a 100644 --- a/src/next/util.ts +++ b/src/next/util.ts @@ -13,14 +13,29 @@ export function getScope(node: ts.Node): ts.Node { return node; } - if (this.isScope(node.kind)) { + if (isScopeKind(node.kind)) { return node; } - return this.getScope(node.parent); + return getScope(node.parent); } -export function isScope(kind: ts.SyntaxKind): boolean { +// TODO: test +export function identifierExistsUp(node: ts.Node, id: string | ts.Identifier) { + if (typeof id !== 'string') id = id.text; + let current = node; + while (current.parent) current = current.parent; + return identifierExistsDown(current, id, node); +} + +// TODO: test +export function identifierExistsDown(node: ts.Node, id: string, stop?: ts.Node): boolean { + if (!node || node === stop) return false; + return node.kind === ts.SyntaxKind.Identifier && (node as ts.Identifier).text === id ? + true : !!ts.forEachChild(node, n => identifierExistsDown(n, id, stop)); +} + +export function isScopeKind(kind: ts.SyntaxKind): boolean { switch (kind) { case ts.SyntaxKind.SourceFile: case ts.SyntaxKind.Block: From ec1c3a743d9f3e7fde6bd451931c866a52834ea9 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Wed, 15 Mar 2017 22:48:37 +0100 Subject: [PATCH 13/26] Minor code style change. --- src/next/transform.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/next/transform.ts b/src/next/transform.ts index a174c25..3da2637 100644 --- a/src/next/transform.ts +++ b/src/next/transform.ts @@ -143,7 +143,7 @@ function transformer(context: ts.TransformationContext): ts.Transformer<ts.Sourc if (DEBUG) { const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; - console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`) + console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); console.log(`Scope: ${scope}`); console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); console.log(`File: ${mutationContext.sourceFile.fileName}`); From 5adb539241bf83dda503851a1d68ef3dff1306c4 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 22:21:15 +0100 Subject: [PATCH 14/26] Added binary expression mutator. Other improvements. --- src/next/mutators/BinaryExpressionMutator.ts | 51 ++++++++++++++ src/next/mutators/Mutator.ts | 4 ++ .../VariableDeclarationListMutator.ts | 70 ++++++++++++++----- 3 files changed, 107 insertions(+), 18 deletions(-) create mode 100644 src/next/mutators/BinaryExpressionMutator.ts diff --git a/src/next/mutators/BinaryExpressionMutator.ts b/src/next/mutators/BinaryExpressionMutator.ts new file mode 100644 index 0000000..fab4bdd --- /dev/null +++ b/src/next/mutators/BinaryExpressionMutator.ts @@ -0,0 +1,51 @@ +import * as ts from 'typescript'; +import * as generator from '../generator'; +import * as util from '../util'; +import { Mutator } from './Mutator'; +import { MutationContext } from '../context'; + +export class BinaryExpressionMutator extends Mutator { + + protected kind = ts.SyntaxKind.BinaryExpression; + + private assignmentKinds: ts.SyntaxKind[] = [ + ts.SyntaxKind.EqualsToken, + ts.SyntaxKind.PlusEqualsToken, + ts.SyntaxKind.MinusEqualsToken, + ts.SyntaxKind.AsteriskAsteriskEqualsToken, + ts.SyntaxKind.AsteriskEqualsToken, + ts.SyntaxKind.SlashEqualsToken, + ts.SyntaxKind.PercentEqualsToken, + ts.SyntaxKind.AmpersandEqualsToken, + ts.SyntaxKind.BarEqualsToken, + ts.SyntaxKind.CaretEqualsToken, + ts.SyntaxKind.LessThanLessThanEqualsToken, + ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, + ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, + ]; + + public mutate(node: ts.BinaryExpression): ts.Node { + if (this.assignmentKinds.indexOf(node.operatorToken.kind) === -1) { + return node; + } + + + if (node.left.kind !== ts.SyntaxKind.Identifier) { + return node; + } + + const implicitType = this.context.getImplicitTypeNode(node.left); + + if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) { + return node; + } + + const nodeName = this.context.getTypeDeclarationName(node.left as ts.Identifier); + const right = generator.typeAssertion(nodeName, node.right); + + this.context.addVisited(right, true, node.right); + + return ts.updateBinary(node, node.left, right); + } + +} diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts index a5454a4..0a91a12 100644 --- a/src/next/mutators/Mutator.ts +++ b/src/next/mutators/Mutator.ts @@ -8,7 +8,11 @@ export abstract class Mutator { protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node; + protected context: MutationContext; + public mutateNode(node: ts.Node, context: MutationContext): ts.Node { + this.context = context; + if (this.getKind().indexOf(node.kind) === -1) { return node; } diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/next/mutators/VariableDeclarationListMutator.ts index 32ba992..c18daab 100644 --- a/src/next/mutators/VariableDeclarationListMutator.ts +++ b/src/next/mutators/VariableDeclarationListMutator.ts @@ -1,5 +1,6 @@ import * as ts from 'typescript'; import * as generator from '../generator'; +import * as util from '../util'; import { Mutator } from './Mutator'; import { MutationContext } from '../context'; @@ -7,7 +8,7 @@ export class VariableDeclarationListMutator extends Mutator { protected kind = ts.SyntaxKind.VariableDeclarationList; - public mutate(node: ts.VariableDeclarationList, context: MutationContext): ts.Node { + public mutate(node: ts.VariableDeclarationList): ts.Node { if (!node.declarations) { return node; } @@ -15,15 +16,15 @@ export class VariableDeclarationListMutator extends Mutator { const declarations: ts.VariableDeclaration[] = []; for (const declaration of node.declarations) { - const transformed = this.transformDeclaration(declaration, context); - transformed.forEach(n => context.addVisited(n, true)); + const transformed = this.transform(declaration, this.context); + transformed.forEach(n => this.context.addVisited(n, true, n.initializer)); declarations.push(...transformed); } return ts.updateVariableDeclarationList(node, declarations); } - private transformDeclaration(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] { + private transform(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] { if (context.wasVisited(node)) { return [node]; } @@ -35,49 +36,82 @@ export class VariableDeclarationListMutator extends Mutator { return this.transformUntypedConstDeclaration(node); } - return this.transformUntypedLetDeclaration(node); + return this.transformUntypedDeclaration(node); } if (isConst) { return this.transformConstDeclaration(node); } - return this.transformLetDeclaration(node); + return this.transformDeclaration(node); } - private transformLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { - const nodeName = node.name.getText(); - const typeDefinition = generator.typeDefinition(`_${nodeName}Type`, node.type); + private transformDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + if (!this.context.options.assertAny && node.type.kind === ts.SyntaxKind.AnyKeyword) { + return [node]; + } + + const nodeName = this.context.getTypeDeclarationName(node.name.getText()); + const typeDefinition = generator.typeDeclaration(nodeName, node.type); if (!node.initializer) { return [typeDefinition, node]; } - const initializer = generator.propertyAccessCall(`_${nodeName}Type`, 'assert', node.initializer); + const initializer = generator.typeAssertion(nodeName, node.initializer); const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); return [typeDefinition, assignment]; } private transformConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { - const nodeName = node.name.getText(); - const typeCalls = generator.typeAssertion(node.type); + if (!this.context.options.assertAny && node.type.kind === ts.SyntaxKind.AnyKeyword) { + return [node]; + } - const initializer = ts.createCall( - ts.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer], - ); + const nodeName = this.context.getTypeDeclarationName(node.name.getText()); + const initializer = generator.typeDefinitionAndAssertion(node.type, node.initializer); const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); return [assignment]; } - private transformUntypedLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { - return [node]; + private transformUntypedDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { + const nodeName = this.context.getTypeDeclarationName(node.name.getText()); + const implicitType = this.context.getImplicitTypeNode(node.name); + + if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) { + return [node]; + } + + const typeDefinition = generator.typeDeclaration( + nodeName, + implicitType + ); + + if (!node.initializer) { + return [typeDefinition, node]; + } + + const initializer = generator.typeAssertion(nodeName, [node.initializer]); + const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); + + return [typeDefinition, assignment]; } private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { - return [node]; + const nodeName = this.context.getTypeDeclarationName(node.name.getText()); + const implicitType = this.context.getImplicitTypeNode(node.name); + + if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) { + return [node]; + } + + const initializer = generator.typeDefinitionAndAssertion(implicitType, node.initializer); + const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer); + + return [assignment]; } } From 7004d0f485b46ddb82ded6f060060640dde96e43 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 22:22:33 +0100 Subject: [PATCH 15/26] Check implicit types. Added ability to get type of any identifier. --- src/next/context.ts | 83 +++++++- src/next/generator.ts | 31 ++- src/next/mutators.ts | 2 + src/next/options.ts | 2 + src/next/transform.ts | 430 ++++++++++++++++++++++++++---------------- 5 files changed, 371 insertions(+), 177 deletions(-) diff --git a/src/next/context.ts b/src/next/context.ts index a0ce6d1..0b3a6dd 100644 --- a/src/next/context.ts +++ b/src/next/context.ts @@ -1,17 +1,27 @@ import * as ts from 'typescript'; import * as util from './util'; +import { Options } from './options'; export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock; export class MutationContext { + private _options: Options; private _sourceFile: ts.SourceFile; + private _program: ts.Program; + private _checker: ts.TypeChecker; + private _host: ts.CompilerHost; private _scope: Scope; private _visited: ts.Node[]; private _transformationContext: ts.TransformationContext; - constructor(sf?: ts.SourceFile) { - this._scope = sf; + constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost) { + this._options = options; + this._sourceFile = sourceFile; + this._program = program; + this._checker = program.getTypeChecker(); + this._host = host; + this._scope = sourceFile; this._visited = []; } @@ -23,8 +33,8 @@ export class MutationContext { return false; } - public addVisited(node: ts.Node, recursive = false): void { - if (!this.wasVisited(node)) { + public addVisited(node: ts.Node, recursive = false, ...exclude: ts.Node[]): void { + if (!this.wasVisited(node) && exclude.indexOf(node) === -1) { this._visited.push(node); } @@ -46,18 +56,39 @@ export class MutationContext { return false; } - public setScope(node: ts.Node): void { - this.scope = node; + // TODO: implement + public getTypeDeclarationName(node: string | ts.BindingName): string { + const name = typeof node === 'string' ? node : node.getText(); + return `_${name}Type`; } - public setTransformationContext(transformationContext: ts.TransformationContext): void { - this.transformationContext = transformationContext; + // TODO: implement + public getLibDeclarationName(): string { + return ''; } - public setSourceFile(sourceFile: ts.Node): void { - this.sourceFile = sourceFile as ts.SourceFile; + public getImplicitTypeNode(node: ts.Node): ts.TypeNode { + let type = this.checker.getTypeAtLocation(node); + let typeString = this.checker.typeToString(type); + let source = `let temp: ${typeString};`; + let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS); + return (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; + } + + public getType(node: ts.Node): ts.Type { + return this.checker.getTypeAtLocation(node); } + public getTypeFlag(node: ts.Node): ts.TypeFlags { + return this.getType(node).flags; + } + + public getTypeFlagString(node: ts.Node): string { + return ts.TypeFlags[this.getTypeFlag(node)]; + } + + // getters and setters + get transformationContext() { return this._transformationContext; } @@ -66,6 +97,10 @@ export class MutationContext { this._transformationContext = transformationContext; } + public setTransformationContext(transformationContext: ts.TransformationContext): void { + this.transformationContext = transformationContext; + } + get visited() { return this._visited; } @@ -88,6 +123,10 @@ export class MutationContext { } } + public setScope(node: ts.Node): void { + this.scope = node; + } + get sourceFile() { return this._sourceFile; } @@ -100,4 +139,28 @@ export class MutationContext { this._sourceFile = sourceFile; } + public setSourceFile(sourceFile: ts.Node): void { + this.sourceFile = sourceFile as ts.SourceFile; + } + + get compilerOptions() { + return this._options.compilerOptions; + } + + get options() { + return this._options; + } + + get program() { + return this._program; + } + + get checker() { + return this._checker; + } + + get host() { + return this._host; + } + } diff --git a/src/next/generator.ts b/src/next/generator.ts index 69e4c62..dc7f10c 100644 --- a/src/next/generator.ts +++ b/src/next/generator.ts @@ -1,12 +1,29 @@ import * as ts from 'typescript'; -export const LIB = 't'; +let LIB = 't'; -export function typeDefinition(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration { - return ts.createVariableDeclaration(name, undefined, typeAssertion(type)); +export function setLib(lib: string): void { + LIB = lib; } -export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression { +export function getLib(): string { + return LIB; +} + +export function typeDeclaration(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration { + return ts.createVariableDeclaration(name, undefined, typeDefinition(type)); +} + +export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression { + return typeAssertion(typeDefinition(type), args, types); +} + +export function typeAssertion(id: string | ts.Expression, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression { + return propertyAccessCall(id, 'assert', args, types); +} + +// TODO: Add ParenthesizedType (among others) +export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { if (!type) { return null; } @@ -28,7 +45,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression { case ts.SyntaxKind.ArrayType: { const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode; - const callExpression = propertyAccessCall(LIB, 'array', typeAssertion(typeNode)); + const callExpression = propertyAccessCall(LIB, 'array', typeDefinition(typeNode)); return callExpression; } case ts.SyntaxKind.TypeReference: @@ -40,7 +57,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression { if (typeRef.typeArguments) { for (const arg of typeRef.typeArguments) { - args.push(typeAssertion(arg)); + args.push(typeDefinition(arg)); } } @@ -58,7 +75,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression { const args: ts.CallExpression[] = []; for (const arg of typeRef.elementTypes) { - args.push(typeAssertion(arg)); + args.push(typeDefinition(arg)); } return propertyAccessCall(LIB, 'tuple', args); diff --git a/src/next/mutators.ts b/src/next/mutators.ts index 8b0c215..1d7b6dc 100644 --- a/src/next/mutators.ts +++ b/src/next/mutators.ts @@ -1,9 +1,11 @@ import { Mutator } from './mutators/Mutator'; +import { BinaryExpressionMutator } from './mutators/BinaryExpressionMutator'; import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator'; import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator'; export const mutators: Mutator[] = [ + new BinaryExpressionMutator(), new InterfaceDeclarationMutator(), new VariableDeclarationListMutator(), ]; diff --git a/src/next/options.ts b/src/next/options.ts index cba0e41..3c3387f 100644 --- a/src/next/options.ts +++ b/src/next/options.ts @@ -2,6 +2,7 @@ import * as ts from 'typescript'; export interface Options { compilerOptions?: ts.CompilerOptions; + assertAny?: boolean; keepTempFiles?: boolean; tempFolderName?: string; } @@ -12,6 +13,7 @@ export const defaultOptions: Options = { module: ts.ModuleKind.ES2015, target: ts.ScriptTarget.ES2015 }, + assertAny: false, keepTempFiles: true, tempFolderName: '.tsr' }; diff --git a/src/next/transform.ts b/src/next/transform.ts index 3da2637..72a9982 100644 --- a/src/next/transform.ts +++ b/src/next/transform.ts @@ -7,222 +7,332 @@ import { MutationContext } from './context'; import { mutators } from './mutators'; import { Options, defaultOptions } from './options'; -const DEBUG = true; +const DEBUG = false; -export function transform(entryFile: string, options?: Options): void { +export function transform(entryFile: string, options?: Options) { options = getOptions(options); - notify(bus.events.START, { entryFile, options }); - const basePath = path.dirname(entryFile); - const host = ts.createCompilerHost(options.compilerOptions); - const program = ts.createProgram([entryFile], options.compilerOptions, host); + let host: ts.CompilerHost; + let program: ts.Program; - const diagnostics: ts.Diagnostic[] = []; + startTransformation(); - diagnostics.push(...program.getOptionsDiagnostics()); - diagnostics.push(...program.getGlobalDiagnostics()); + function startTransformation(): void { + notify(bus.events.START, { entryFile, options }); - for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { - diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); - diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); - } - - if (!check(diagnostics)) { - notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); - } + const basePath = path.dirname(entryFile); - const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); + host = ts.createCompilerHost(options.compilerOptions); + program = ts.createProgram([entryFile], options.compilerOptions, host); - notify(bus.events.TRANSFORM_START, { sourceFiles }); - const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); - notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); + const diagnostics: ts.Diagnostic[] = []; - if (!check(result.diagnostics)) { - notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); - } + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); - const printerOptions: ts.PrinterOptions = { - target: options.compilerOptions.target, - removeComments: false - }; - - const printHandlers: ts.PrintHandlers = { - substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node { - return node; + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); } - }; - - notify(bus.events.WRITE_START, { count: result.transformed.length }); - const printer = ts.createPrinter(printerOptions, printHandlers); - - let count = 0; - for (let transformed of result.transformed) { - count++; - const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); - const source = printer.printFile(transformed); - notify(bus.events.WRITE_FILE_START, { location, transformed, source }); - ts.sys.writeFile(location, source); - notify(bus.events.WRITE_FILE_END, { location, transformed, source }); - } - notify(bus.events.WRITE_END, { count }); + if (!check(diagnostics)) { + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); + } - result.dispose(); + const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); - emit(entryFile, options); + notify(bus.events.TRANSFORM_START, { sourceFiles }); + const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); + notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); - if (!options.keepTempFiles) { - const tempPath = getTempPath(basePath, options.tempFolderName); - notify(bus.events.TEMP_DELETE_START, { tempPath }); - rimraf.sync(getTempPath(basePath, options.tempFolderName)); - notify(bus.events.TEMP_DELETE_END, { tempPath }); - } + if (!check(result.diagnostics)) { + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); + } - notify(bus.events.END, { entryFile, options }); -} + const printerOptions: ts.PrinterOptions = { + target: options.compilerOptions.target, + removeComments: false + }; -export function emit(entryFile: string, options: Options) { - const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); - notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); + const printHandlers: ts.PrintHandlers = { + substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node { + return node; + } + }; + + notify(bus.events.WRITE_START, { count: result.transformed.length }); + const printer = ts.createPrinter(printerOptions, printHandlers); + + let count = 0; + for (let transformed of result.transformed) { + count++; + const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); + const source = printer.printFile(transformed); + notify(bus.events.WRITE_FILE_START, { location, transformed, source }); + ts.sys.writeFile(location, source); + notify(bus.events.WRITE_FILE_END, { location, transformed, source }); + } - options.compilerOptions.outDir = path.dirname(entryFile); + notify(bus.events.WRITE_END, { count }); - const host = ts.createCompilerHost(options.compilerOptions); - const program = ts.createProgram([tempEntryFile], options.compilerOptions, host); + result.dispose(); - const diagnostics: ts.Diagnostic[] = []; + emit(); - diagnostics.push(...program.getOptionsDiagnostics()); - diagnostics.push(...program.getGlobalDiagnostics()); + if (!options.keepTempFiles) { + const tempPath = getTempPath(basePath, options.tempFolderName); + notify(bus.events.TEMP_DELETE_START, { tempPath }); + rimraf.sync(getTempPath(basePath, options.tempFolderName)); + notify(bus.events.TEMP_DELETE_END, { tempPath }); + } - for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { - diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); - diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + notify(bus.events.END, { entryFile, options }); } + function emit() { + const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); + notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); - if (!check(diagnostics)) { - notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); - notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); - } + options.compilerOptions.outDir = path.dirname(entryFile); - const emitResult = program.emit(); + host = ts.createCompilerHost(options.compilerOptions); + program = ts.createProgram([tempEntryFile], options.compilerOptions, host); - if (!check(emitResult.diagnostics)) { - notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); - notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); - } + const diagnostics: ts.Diagnostic[] = []; - notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); -} + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); -function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { - if (util.isKind(node, ts.SyntaxKind.SourceFile)) { - mc.setSourceFile(node); - } + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + } - mc.setTransformationContext(tc); - mc.setScope(util.getScope(node)); - return node; -} + if (!check(diagnostics)) { + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); + } -function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { - mc.addVisited(node); - return node; -} + const emitResult = program.emit(); -function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { - const mutationContext = new MutationContext(); + if (!check(emitResult.diagnostics)) { + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); + } - const visitor: ts.Visitor = (node: ts.Node): ts.Node => { - const parent = node.parent; - node = onBeforeVisit(node, mutationContext, context); + notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); + } - if (DEBUG) { - const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; - console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); - console.log(`Scope: ${scope}`); - console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); - console.log(`File: ${mutationContext.sourceFile.fileName}`); + function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + if (util.isKind(node, ts.SyntaxKind.SourceFile)) { + mc.setSourceFile(node); } - for (let mutator of mutators) { - node = mutator.mutateNode(node, mutationContext); - } + mc.setTransformationContext(tc); + mc.setScope(util.getScope(node)); + + return node; + } + + function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.addVisited(node); + return node; + } - node.parent = parent; - util.setParent(node); + // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void { + // if (!node) return; + // let checker = program.getTypeChecker(); + // ts.forEachChild(node, n => { + // + // + // // let type = checker.getTypeAtLocation(n); + // // // console.log('TYPE', type); + // // let typeString = checker.typeToString(type); + // // console.log('TYPESTRING', typeString); + // // let source = `let temp: ${typeString};`; + // // console.log('SRC', source); + // // console.log('\n\n\n'); + // // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); + // // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; + // + // switch (n.kind) { + // case ts.SyntaxKind.BinaryExpression: + // // console.log((n as ts.BinaryExpression).getText()); + // // let s = program.getTypeChecker().getSymbolAtLocation(n); + // // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression); + // // console.log(s); + // // console.log(t); + // // console.log('\n\n'); + // break; + // case ts.SyntaxKind.Identifier: + // console.log((n as ts.Identifier).text); + // console.log('-----------------------'); + // + // + // + // // let t = checker.getTypeAtLocation(n); + // // // console.log(checker.getPropertiesOfType(t)); + // // // t = checker.getWidenedType(t); + // // // + // // console.log(ts.TypeFlags[t.flags]); + // + // let type = checker.getTypeAtLocation(n); + // + // let typeString = checker.typeToString(type); + // console.log(typeString); + // let source = `let temp: ${typeString};`; + // + // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); + // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; + // + // // + // // let asm = type.aliasSymbol; + // // + // // if (asm) { + // // if (asm.declarations && asm.declarations[0]) { + // // console.log(asm.declarations.length); + // // let asmi = asm.declarations[0] as ts.VariableDeclaration; + // // if (asmi.type) { + // // console.log('has type'); + // // console.log(ts.SyntaxKind[asmi.type.kind]); + // // } + // // } + // // } + // // + // console.log(ts.TypeFlags[type.flags]); + // console.log('\n\n'); + // + // // console.log('KIND:', (n as ts.Identifier).text); + // // console.log((n as ts.Identifier).originalKeywordKind); + // // console.log(''); + // + // // if (mc.names.indexOf((n as ts.Identifier).text) === -1) { + // // // mc.names.push((n as ts.Identifier).text); + // // // console.log('KIND:', (n as ts.Identifier).text); + // // // console.log((n as ts.Identifier).originalKeywordKind); + // // // console.log(''); + // // } + // break; + // case ts.SyntaxKind.VariableDeclaration: + // // const dec = n as ts.VariableDeclaration; + // // if (dec.name.kind === ts.SyntaxKind.Identifier) { + // // mc.declarations.set((dec.name as ts.Identifier).text, dec.type); + // // } + // break; + // } + // + // firstPassVisitor(n, mc, tc); + // }); + // } + + function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + let mutationContext: MutationContext; + + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + if (node.kind === ts.SyntaxKind.SourceFile) { + mutationContext = new MutationContext(options, node as ts.SourceFile, program, host); + // firstPassVisitor(node as ts.SourceFile, mutationContext, context); + } - if (DEBUG) { - console.log('<============================================'); - if (node.parent) { - if (node.flags === ts.NodeFlags.Synthesized) { - console.log('Cannot get text of synthesized node.'); + // if (node.kind === ts.SyntaxKind.SourceFile) { + // console.log('---------------'); + // console.log('SourceFile'); + // console.log((node as ts.SourceFile).fileName); + // console.log('---------------\n\n'); + // } else { + // console.log(ts.SyntaxKind[node.kind]); + // } + + const parent = node.parent; + node = onBeforeVisit(node, mutationContext, context); + + if (DEBUG) { + const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; + console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); + console.log(`Scope: ${scope}`); + console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); + console.log(`File: ${mutationContext.sourceFile.fileName}`); + } + + for (let mutator of mutators) { + node = mutator.mutateNode(node, mutationContext); + } + + node.parent = parent; + util.setParent(node); + + if (DEBUG) { + console.log('<============================================'); + if (node.parent) { + if (node.flags === ts.NodeFlags.Synthesized) { + console.log('Cannot get text of synthesized node.'); + } else { + console.log(node.getText()); + } } else { - console.log(node.getText()); + console.log('Parent not set, cannot get text.'); } - } else { - console.log('Parent not set, cannot get text.'); + console.log('============================================>'); } - console.log('============================================>'); - } - if (DEBUG) { - console.log('\n\n'); - } + if (DEBUG) { + console.log('\n\n'); + } - node = onAfterVisit(node, mutationContext, context); + node = onAfterVisit(node, mutationContext, context); - return ts.visitEachChild(node, visitor, context); - }; + return ts.visitEachChild(node, visitor, context); + }; - return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); -} + return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); + } -function getOptions(options: Options = {}): Options { - const opts = Object.assign({}, defaultOptions, options); - opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {}); - return opts; -} + function getOptions(o: Options = {}): Options { + const opts = Object.assign({}, defaultOptions, o); + opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, o.compilerOptions || {}); + return opts; + } + + function getRootNames(rootNames: string | string[]): string[] { + if (Array.isArray(rootNames)) { + return rootNames; + } -function getRootNames(rootNames: string | string[]): string[] { - if (Array.isArray(rootNames)) { - return rootNames; + return [rootNames]; } - return [rootNames]; -} + function getTempPath(basePath: string, tempFolderName: string): string { + return path.join(basePath, tempFolderName); + } -function getTempPath(basePath: string, tempFolderName: string): string { - return path.join(basePath, tempFolderName); -} + function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { + const pathFromBase = path.dirname(file.replace(basePath, '')); + const tempPath = getTempPath(basePath, tempFolderName); + const fileName = path.basename(file); -function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { - const pathFromBase = path.dirname(file.replace(basePath, '')); - const tempPath = getTempPath(basePath, tempFolderName); - const fileName = path.basename(file); + return path.join(tempPath, pathFromBase, fileName); + } - return path.join(tempPath, pathFromBase, fileName); -} + function check(diagnostics: ts.Diagnostic[]): boolean { + if (diagnostics && diagnostics.length > 0) { + notify(bus.events.DIAGNOSTICS, { diagnostics }); + console.error(ts.formatDiagnostics(diagnostics, { + getCurrentDirectory: () => ts.sys.getCurrentDirectory(), + getNewLine: () => ts.sys.newLine, + getCanonicalFileName: (f: string) => f + })); + return false; + } -function check(diagnostics: ts.Diagnostic[]): boolean { - if (diagnostics && diagnostics.length > 0) { - notify(bus.events.DIAGNOSTICS, { diagnostics }); - console.error(ts.formatDiagnostics(diagnostics, { - getCurrentDirectory: () => ts.sys.getCurrentDirectory(), - getNewLine: () => ts.sys.newLine, - getCanonicalFileName: (f: string) => f - })); - return false; + return true; } - return true; -} + function notify(event: string | symbol, ...args: any[]): boolean { + return bus.emitter.emit(event, args); + } -function notify(event: string | symbol, ...args: any[]): boolean { - return bus.emitter.emit(event, args); } From dc0c571b8119e54b617ee5943b30dc23b8bb76b9 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 22:22:46 +0100 Subject: [PATCH 16/26] Changes to linter rules. --- tslint.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tslint.json b/tslint.json index 4b8c6d7..ad5628a 100644 --- a/tslint.json +++ b/tslint.json @@ -22,7 +22,8 @@ "array-type": false, "trailing-comma": false, "variable-name": false, - "no-conditional-assignment": false + "no-conditional-assignment": false, + "switch-default": false }, "jsRules": { From 9dab0f6df45a4dada34b1c1f2c11a259ec6e3a9c Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 22:23:03 +0100 Subject: [PATCH 17/26] Temporary test output. --- src/test/v2/.tsr/source3.ts | 2 +- src/test/v2/.tsr/source4.ts | 18 ++++++++++++++++-- src/test/v2/source3.js | 2 +- src/test/v2/source4.js | 18 ++++++++++++++++-- src/test/v2/source4.ts | 32 ++++++++++++++++++++++++++++---- 5 files changed, 62 insertions(+), 10 deletions(-) diff --git a/src/test/v2/.tsr/source3.ts b/src/test/v2/.tsr/source3.ts index c019563..39b6023 100644 --- a/src/test/v2/.tsr/source3.ts +++ b/src/test/v2/.tsr/source3.ts @@ -1 +1 @@ -export const bla = 'bla'; +export const bla = t.any().assert('bla'); diff --git a/src/test/v2/.tsr/source4.ts b/src/test/v2/.tsr/source4.ts index 027a7c7..e58abd9 100644 --- a/src/test/v2/.tsr/source4.ts +++ b/src/test/v2/.tsr/source4.ts @@ -1,10 +1,24 @@ +import { bla } from './source3'; +console.log(bla); type TestType = { name: string; }; -const a: string = t.string().assert(10); +const a: string = t.string().assert('hallo'); let _bType = t.array(t.number()), b: number[]; -b = [a]; +b = _bType.assert([10]); function testFunction(t: TestType): string { return 'Hello ' + t.name; } console.log(testFunction({ name: 'Alice' })); +let hasAnyType: any; +hasAnyType = 55; +const constAny: any = 10; +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi: string; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; diff --git a/src/test/v2/source3.js b/src/test/v2/source3.js index c019563..39b6023 100644 --- a/src/test/v2/source3.js +++ b/src/test/v2/source3.js @@ -1 +1 @@ -export const bla = 'bla'; +export const bla = t.any().assert('bla'); diff --git a/src/test/v2/source4.js b/src/test/v2/source4.js index 4017790..838722f 100644 --- a/src/test/v2/source4.js +++ b/src/test/v2/source4.js @@ -1,7 +1,21 @@ -const a = t.string().assert(10); +import { bla } from './source3'; +console.log(bla); +const a = t.string().assert('hallo'); let _bType = t.array(t.number()), b; -b = [a]; +b = _bType.assert([10]); function testFunction(t) { return 'Hello ' + t.name; } console.log(testFunction({ name: 'Alice' })); +let hasAnyType; +hasAnyType = 55; +const constAny = 10; +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; diff --git a/src/test/v2/source4.ts b/src/test/v2/source4.ts index 4d5ad9f..e3fee78 100644 --- a/src/test/v2/source4.ts +++ b/src/test/v2/source4.ts @@ -1,13 +1,37 @@ +import { bla } from './source3'; + +console.log(bla); + type TestType = { name: string; -} +}; -const a: string = 10; +const a: string = 'hallo'; let b: number[]; -b = [a]; +b = [10]; -function testFunction (t: TestType): string { +function testFunction(t: TestType): string { return 'Hello ' + t.name; } console.log(testFunction({name: 'Alice'})); + +let hasAnyType: any; +hasAnyType = 55; + +const constAny: any = 10; + +let x = [5, 10]; + +let hasNoType; +hasNoType = 5; + +var hi: string; + +hi = console; + +const y = ['hallo', 'du']; + +x = 5; +x = 'hi'; +hasNoType = 'str'; From 4fdb52d06697f48c0d4380427640a714624da031 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 23:32:36 +0100 Subject: [PATCH 18/26] Move next code to src. --- src/{ => _archived}/bin/handlers.ts | 0 src/{ => _archived}/bin/index.ts | 0 src/{ => _archived}/bin/status.ts | 0 .../src/bus.js => _archived/bus.ts} | 0 src/{ => _archived}/bus/Bus.ts | 0 src/{ => _archived}/compiler.ts | 0 src/{ => _archived}/compiler/Compiler.ts | 0 .../compiler/CompilerConfig.ts | 0 src/{ => _archived}/compiler/CompilerMode.ts | 0 .../compiler/CompilerResult.ts | 0 src/{ => _archived}/compiler/FileResult.ts | 0 .../compiler/_archive/generators.ts | 0 .../_archive/generators/class_definition.ts | 0 .../generators/interface_definition.ts | 0 .../_archive/generators/type_definition.ts | 0 .../generators/variable_assignment.ts | 0 .../compiler/_archive/utils.ts | 0 .../compiler/_archive/utils/ast.ts | 0 .../compiler/_archive/visitors.ts | 0 .../_archive/visitors/ClassVisitor.ts | 0 .../visitors/ExpressionStatementVisitor.ts | 0 .../_archive/visitors/InterfaceVisitor.js | 0 .../_archive/visitors/TypeParameterVisitor.ts | 0 .../visitors/VariableDeclarationVisitor.ts | 0 .../visitors/VariableStatementVisitor.ts | 0 .../_archive/visitors/default_visitors.ts | 0 .../VariableDeclarationVisitor.ts | 0 .../compiler/_archive/visitors_new/Visitor.ts | 0 .../_archive/visitors_new/default_visitors.ts | 0 .../compiler/default_config.ts | 0 src/{ => _archived}/compiler/transformers.ts | 0 .../FunctionDeclarationTransformer.ts | 0 .../transformers/HasStatementsTransformer.ts | 0 .../compiler/transformers/Transformer.ts | 0 .../transformers/TransformerConfig.ts | 0 .../VariableDeclarationTransformer.ts | 0 .../compiler/transformers/default_config.ts | 0 .../transformers/default_transformers.ts | 0 src/{ => _archived}/compiler/utils.ts | 0 .../compiler/utils/generator.ts | 0 src/{ => _archived}/config.ts | 0 src/{ => _archived}/config/Config.ts | 0 src/{ => _archived}/config/default_config.ts | 0 src/_archived/index.ts | 1 + src/{ => _archived}/lib/bundle.js | 0 src/{ => _archived}/lib/implement.js | 0 src/{ => _archived}/lib/implements.js | 0 src/{ => _archived}/lib/index.js | 0 src/{ => _archived}/lib/r.ts | 0 src/{ => _archived}/lib/t.ts | 0 .../Development/ts-runtime/src/bus.js | 1 + .../Development/ts-runtime/src/compiler.js | 0 .../ts-runtime/src/compiler/Compiler.js | 0 src/{ => _archived}/playground/index.ts | 0 src/{ => _archived}/playground/package.json | 0 .../playground/simple_example.ts | 0 src/{ => _archived}/playground/test.js | 0 src/{ => _archived}/playground/test.ts | 0 src/{ => _archived}/playground/test0.js | 0 src/{ => _archived}/playground/test0.ts | 0 src/{ => _archived}/playground/test1.js | 0 src/{ => _archived}/playground/test1.ts | 0 src/{ => _archived}/playground/test2.js | 0 src/{ => _archived}/playground/test2.ts | 0 src/{ => _archived}/playground/test3.js | 0 src/{ => _archived}/playground/test3.ts | 0 src/{ => _archived}/playground/test4.js | 0 src/{ => _archived}/playground/test4.ts | 0 src/{ => _archived}/playground/yarn.lock | 0 .../test/config-2017-03-10_17-40-38-656.ts | 0 src/{ => _archived}/test/factory.ts | 0 src/{ => _archived}/test/source.js | 0 src/{ => _archived}/test/source.ts | 0 src/{ => _archived}/test/test.ts | 0 src/{ => _archived}/test/transformer.ts | 0 src/{ => _archived}/test/v1.ts | 0 src/{ => _archived}/test/v2/.tsr/source.ts | 0 src/{ => _archived}/test/v2/.tsr/source2.ts | 0 src/{ => _archived}/test/v2/.tsr/source3.ts | 0 src/{ => _archived}/test/v2/.tsr/source4.ts | 0 src/{ => _archived}/test/v2/source.js | 0 src/{ => _archived}/test/v2/source.ts | 0 src/{ => _archived}/test/v2/source2.js | 0 src/{ => _archived}/test/v2/source2.ts | 0 src/{ => _archived}/test/v2/source3.js | 0 src/{ => _archived}/test/v2/source3.ts | 0 src/{ => _archived}/test/v2/source4.js | 0 src/{ => _archived}/test/v2/source4.ts | 0 src/{ => _archived}/test/v2/test.ts | 0 src/{ => _archived}/test/v2/test2.ts | 0 src/{ => _archived}/test/v2/transform.old.ts | 0 src/_archived/transform.ts | 36 ++ src/{ => _archived}/writer.ts | 0 src/{ => _archived}/writer/Writer.ts | 0 src/{ => _archived}/writer/WriterConfig.ts | 0 src/{ => _archived}/writer/WriterResult.ts | 0 src/{ => _archived}/writer/default_config.ts | 0 src/bus.ts | 29 +- src/{next => }/context.ts | 1 + src/{next => }/generator.ts | 0 src/index.ts | 7 + src/{next => }/mutators.ts | 8 +- .../mutators/BinaryExpressionMutator.ts | 0 .../mutators/InterfaceDeclararionMutator.ts | 0 src/{next => }/mutators/Mutator.ts | 0 .../VariableDeclarationListMutator.ts | 4 + src/next/bus.ts | 28 -- src/next/index.ts | 10 - src/next/transform.ts | 338 ----------------- src/{next => }/options.ts | 0 src/package.json | 5 - src/playground/run.ts | 6 + src/playground/snippets/.tsr/source3.ts | 35 ++ src/playground/snippets/.tsr/source4.ts | 24 ++ src/playground/snippets/source1.ts | 15 + src/playground/snippets/source2.ts | 5 + src/playground/snippets/source3.js | 32 ++ src/playground/snippets/source3.ts | 55 +++ src/playground/snippets/source4.js | 21 ++ src/playground/snippets/source4.ts | 37 ++ src/transform.ts | 352 ++++++++++++++++-- src/{next => }/util.ts | 0 src/yarn.lock | 87 ----- 123 files changed, 642 insertions(+), 495 deletions(-) rename src/{ => _archived}/bin/handlers.ts (100%) rename src/{ => _archived}/bin/index.ts (100%) rename src/{ => _archived}/bin/status.ts (100%) rename src/{playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js => _archived/bus.ts} (100%) rename src/{ => _archived}/bus/Bus.ts (100%) rename src/{ => _archived}/compiler.ts (100%) rename src/{ => _archived}/compiler/Compiler.ts (100%) rename src/{ => _archived}/compiler/CompilerConfig.ts (100%) rename src/{ => _archived}/compiler/CompilerMode.ts (100%) rename src/{ => _archived}/compiler/CompilerResult.ts (100%) rename src/{ => _archived}/compiler/FileResult.ts (100%) rename src/{ => _archived}/compiler/_archive/generators.ts (100%) rename src/{ => _archived}/compiler/_archive/generators/class_definition.ts (100%) rename src/{ => _archived}/compiler/_archive/generators/interface_definition.ts (100%) rename src/{ => _archived}/compiler/_archive/generators/type_definition.ts (100%) rename src/{ => _archived}/compiler/_archive/generators/variable_assignment.ts (100%) rename src/{ => _archived}/compiler/_archive/utils.ts (100%) rename src/{ => _archived}/compiler/_archive/utils/ast.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/ClassVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/ExpressionStatementVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/InterfaceVisitor.js (100%) rename src/{ => _archived}/compiler/_archive/visitors/TypeParameterVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/VariableDeclarationVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/VariableStatementVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors/default_visitors.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors_new/Visitor.ts (100%) rename src/{ => _archived}/compiler/_archive/visitors_new/default_visitors.ts (100%) rename src/{ => _archived}/compiler/default_config.ts (100%) rename src/{ => _archived}/compiler/transformers.ts (100%) rename src/{ => _archived}/compiler/transformers/FunctionDeclarationTransformer.ts (100%) rename src/{ => _archived}/compiler/transformers/HasStatementsTransformer.ts (100%) rename src/{ => _archived}/compiler/transformers/Transformer.ts (100%) rename src/{ => _archived}/compiler/transformers/TransformerConfig.ts (100%) rename src/{ => _archived}/compiler/transformers/VariableDeclarationTransformer.ts (100%) rename src/{ => _archived}/compiler/transformers/default_config.ts (100%) rename src/{ => _archived}/compiler/transformers/default_transformers.ts (100%) rename src/{ => _archived}/compiler/utils.ts (100%) rename src/{ => _archived}/compiler/utils/generator.ts (100%) rename src/{ => _archived}/config.ts (100%) rename src/{ => _archived}/config/Config.ts (100%) rename src/{ => _archived}/config/default_config.ts (100%) create mode 100644 src/_archived/index.ts rename src/{ => _archived}/lib/bundle.js (100%) rename src/{ => _archived}/lib/implement.js (100%) rename src/{ => _archived}/lib/implements.js (100%) rename src/{ => _archived}/lib/index.js (100%) rename src/{ => _archived}/lib/r.ts (100%) rename src/{ => _archived}/lib/t.ts (100%) create mode 100644 src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js rename src/{ => _archived}/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js (100%) rename src/{ => _archived}/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js (100%) rename src/{ => _archived}/playground/index.ts (100%) rename src/{ => _archived}/playground/package.json (100%) rename src/{ => _archived}/playground/simple_example.ts (100%) rename src/{ => _archived}/playground/test.js (100%) rename src/{ => _archived}/playground/test.ts (100%) rename src/{ => _archived}/playground/test0.js (100%) rename src/{ => _archived}/playground/test0.ts (100%) rename src/{ => _archived}/playground/test1.js (100%) rename src/{ => _archived}/playground/test1.ts (100%) rename src/{ => _archived}/playground/test2.js (100%) rename src/{ => _archived}/playground/test2.ts (100%) rename src/{ => _archived}/playground/test3.js (100%) rename src/{ => _archived}/playground/test3.ts (100%) rename src/{ => _archived}/playground/test4.js (100%) rename src/{ => _archived}/playground/test4.ts (100%) rename src/{ => _archived}/playground/yarn.lock (100%) rename src/{ => _archived}/test/config-2017-03-10_17-40-38-656.ts (100%) rename src/{ => _archived}/test/factory.ts (100%) rename src/{ => _archived}/test/source.js (100%) rename src/{ => _archived}/test/source.ts (100%) rename src/{ => _archived}/test/test.ts (100%) rename src/{ => _archived}/test/transformer.ts (100%) rename src/{ => _archived}/test/v1.ts (100%) rename src/{ => _archived}/test/v2/.tsr/source.ts (100%) rename src/{ => _archived}/test/v2/.tsr/source2.ts (100%) rename src/{ => _archived}/test/v2/.tsr/source3.ts (100%) rename src/{ => _archived}/test/v2/.tsr/source4.ts (100%) rename src/{ => _archived}/test/v2/source.js (100%) rename src/{ => _archived}/test/v2/source.ts (100%) rename src/{ => _archived}/test/v2/source2.js (100%) rename src/{ => _archived}/test/v2/source2.ts (100%) rename src/{ => _archived}/test/v2/source3.js (100%) rename src/{ => _archived}/test/v2/source3.ts (100%) rename src/{ => _archived}/test/v2/source4.js (100%) rename src/{ => _archived}/test/v2/source4.ts (100%) rename src/{ => _archived}/test/v2/test.ts (100%) rename src/{ => _archived}/test/v2/test2.ts (100%) rename src/{ => _archived}/test/v2/transform.old.ts (100%) create mode 100644 src/_archived/transform.ts rename src/{ => _archived}/writer.ts (100%) rename src/{ => _archived}/writer/Writer.ts (100%) rename src/{ => _archived}/writer/WriterConfig.ts (100%) rename src/{ => _archived}/writer/WriterResult.ts (100%) rename src/{ => _archived}/writer/default_config.ts (100%) rename src/{next => }/context.ts (99%) rename src/{next => }/generator.ts (100%) rename src/{next => }/mutators.ts (79%) rename src/{next => }/mutators/BinaryExpressionMutator.ts (100%) rename src/{next => }/mutators/InterfaceDeclararionMutator.ts (100%) rename src/{next => }/mutators/Mutator.ts (100%) rename src/{next => }/mutators/VariableDeclarationListMutator.ts (97%) delete mode 100644 src/next/bus.ts delete mode 100644 src/next/index.ts delete mode 100644 src/next/transform.ts rename src/{next => }/options.ts (100%) delete mode 100644 src/package.json create mode 100644 src/playground/run.ts create mode 100644 src/playground/snippets/.tsr/source3.ts create mode 100644 src/playground/snippets/.tsr/source4.ts create mode 100644 src/playground/snippets/source1.ts create mode 100644 src/playground/snippets/source2.ts create mode 100644 src/playground/snippets/source3.js create mode 100644 src/playground/snippets/source3.ts create mode 100644 src/playground/snippets/source4.js create mode 100644 src/playground/snippets/source4.ts rename src/{next => }/util.ts (100%) delete mode 100644 src/yarn.lock diff --git a/src/bin/handlers.ts b/src/_archived/bin/handlers.ts similarity index 100% rename from src/bin/handlers.ts rename to src/_archived/bin/handlers.ts diff --git a/src/bin/index.ts b/src/_archived/bin/index.ts similarity index 100% rename from src/bin/index.ts rename to src/_archived/bin/index.ts diff --git a/src/bin/status.ts b/src/_archived/bin/status.ts similarity index 100% rename from src/bin/status.ts rename to src/_archived/bin/status.ts diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/_archived/bus.ts similarity index 100% rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js rename to src/_archived/bus.ts diff --git a/src/bus/Bus.ts b/src/_archived/bus/Bus.ts similarity index 100% rename from src/bus/Bus.ts rename to src/_archived/bus/Bus.ts diff --git a/src/compiler.ts b/src/_archived/compiler.ts similarity index 100% rename from src/compiler.ts rename to src/_archived/compiler.ts diff --git a/src/compiler/Compiler.ts b/src/_archived/compiler/Compiler.ts similarity index 100% rename from src/compiler/Compiler.ts rename to src/_archived/compiler/Compiler.ts diff --git a/src/compiler/CompilerConfig.ts b/src/_archived/compiler/CompilerConfig.ts similarity index 100% rename from src/compiler/CompilerConfig.ts rename to src/_archived/compiler/CompilerConfig.ts diff --git a/src/compiler/CompilerMode.ts b/src/_archived/compiler/CompilerMode.ts similarity index 100% rename from src/compiler/CompilerMode.ts rename to src/_archived/compiler/CompilerMode.ts diff --git a/src/compiler/CompilerResult.ts b/src/_archived/compiler/CompilerResult.ts similarity index 100% rename from src/compiler/CompilerResult.ts rename to src/_archived/compiler/CompilerResult.ts diff --git a/src/compiler/FileResult.ts b/src/_archived/compiler/FileResult.ts similarity index 100% rename from src/compiler/FileResult.ts rename to src/_archived/compiler/FileResult.ts diff --git a/src/compiler/_archive/generators.ts b/src/_archived/compiler/_archive/generators.ts similarity index 100% rename from src/compiler/_archive/generators.ts rename to src/_archived/compiler/_archive/generators.ts diff --git a/src/compiler/_archive/generators/class_definition.ts b/src/_archived/compiler/_archive/generators/class_definition.ts similarity index 100% rename from src/compiler/_archive/generators/class_definition.ts rename to src/_archived/compiler/_archive/generators/class_definition.ts diff --git a/src/compiler/_archive/generators/interface_definition.ts b/src/_archived/compiler/_archive/generators/interface_definition.ts similarity index 100% rename from src/compiler/_archive/generators/interface_definition.ts rename to src/_archived/compiler/_archive/generators/interface_definition.ts diff --git a/src/compiler/_archive/generators/type_definition.ts b/src/_archived/compiler/_archive/generators/type_definition.ts similarity index 100% rename from src/compiler/_archive/generators/type_definition.ts rename to src/_archived/compiler/_archive/generators/type_definition.ts diff --git a/src/compiler/_archive/generators/variable_assignment.ts b/src/_archived/compiler/_archive/generators/variable_assignment.ts similarity index 100% rename from src/compiler/_archive/generators/variable_assignment.ts rename to src/_archived/compiler/_archive/generators/variable_assignment.ts diff --git a/src/compiler/_archive/utils.ts b/src/_archived/compiler/_archive/utils.ts similarity index 100% rename from src/compiler/_archive/utils.ts rename to src/_archived/compiler/_archive/utils.ts diff --git a/src/compiler/_archive/utils/ast.ts b/src/_archived/compiler/_archive/utils/ast.ts similarity index 100% rename from src/compiler/_archive/utils/ast.ts rename to src/_archived/compiler/_archive/utils/ast.ts diff --git a/src/compiler/_archive/visitors.ts b/src/_archived/compiler/_archive/visitors.ts similarity index 100% rename from src/compiler/_archive/visitors.ts rename to src/_archived/compiler/_archive/visitors.ts diff --git a/src/compiler/_archive/visitors/ClassVisitor.ts b/src/_archived/compiler/_archive/visitors/ClassVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors/ClassVisitor.ts rename to src/_archived/compiler/_archive/visitors/ClassVisitor.ts diff --git a/src/compiler/_archive/visitors/ExpressionStatementVisitor.ts b/src/_archived/compiler/_archive/visitors/ExpressionStatementVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors/ExpressionStatementVisitor.ts rename to src/_archived/compiler/_archive/visitors/ExpressionStatementVisitor.ts diff --git a/src/compiler/_archive/visitors/InterfaceVisitor.js b/src/_archived/compiler/_archive/visitors/InterfaceVisitor.js similarity index 100% rename from src/compiler/_archive/visitors/InterfaceVisitor.js rename to src/_archived/compiler/_archive/visitors/InterfaceVisitor.js diff --git a/src/compiler/_archive/visitors/TypeParameterVisitor.ts b/src/_archived/compiler/_archive/visitors/TypeParameterVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors/TypeParameterVisitor.ts rename to src/_archived/compiler/_archive/visitors/TypeParameterVisitor.ts diff --git a/src/compiler/_archive/visitors/VariableDeclarationVisitor.ts b/src/_archived/compiler/_archive/visitors/VariableDeclarationVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors/VariableDeclarationVisitor.ts rename to src/_archived/compiler/_archive/visitors/VariableDeclarationVisitor.ts diff --git a/src/compiler/_archive/visitors/VariableStatementVisitor.ts b/src/_archived/compiler/_archive/visitors/VariableStatementVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors/VariableStatementVisitor.ts rename to src/_archived/compiler/_archive/visitors/VariableStatementVisitor.ts diff --git a/src/compiler/_archive/visitors/default_visitors.ts b/src/_archived/compiler/_archive/visitors/default_visitors.ts similarity index 100% rename from src/compiler/_archive/visitors/default_visitors.ts rename to src/_archived/compiler/_archive/visitors/default_visitors.ts diff --git a/src/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts b/src/_archived/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts similarity index 100% rename from src/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts rename to src/_archived/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts diff --git a/src/compiler/_archive/visitors_new/Visitor.ts b/src/_archived/compiler/_archive/visitors_new/Visitor.ts similarity index 100% rename from src/compiler/_archive/visitors_new/Visitor.ts rename to src/_archived/compiler/_archive/visitors_new/Visitor.ts diff --git a/src/compiler/_archive/visitors_new/default_visitors.ts b/src/_archived/compiler/_archive/visitors_new/default_visitors.ts similarity index 100% rename from src/compiler/_archive/visitors_new/default_visitors.ts rename to src/_archived/compiler/_archive/visitors_new/default_visitors.ts diff --git a/src/compiler/default_config.ts b/src/_archived/compiler/default_config.ts similarity index 100% rename from src/compiler/default_config.ts rename to src/_archived/compiler/default_config.ts diff --git a/src/compiler/transformers.ts b/src/_archived/compiler/transformers.ts similarity index 100% rename from src/compiler/transformers.ts rename to src/_archived/compiler/transformers.ts diff --git a/src/compiler/transformers/FunctionDeclarationTransformer.ts b/src/_archived/compiler/transformers/FunctionDeclarationTransformer.ts similarity index 100% rename from src/compiler/transformers/FunctionDeclarationTransformer.ts rename to src/_archived/compiler/transformers/FunctionDeclarationTransformer.ts diff --git a/src/compiler/transformers/HasStatementsTransformer.ts b/src/_archived/compiler/transformers/HasStatementsTransformer.ts similarity index 100% rename from src/compiler/transformers/HasStatementsTransformer.ts rename to src/_archived/compiler/transformers/HasStatementsTransformer.ts diff --git a/src/compiler/transformers/Transformer.ts b/src/_archived/compiler/transformers/Transformer.ts similarity index 100% rename from src/compiler/transformers/Transformer.ts rename to src/_archived/compiler/transformers/Transformer.ts diff --git a/src/compiler/transformers/TransformerConfig.ts b/src/_archived/compiler/transformers/TransformerConfig.ts similarity index 100% rename from src/compiler/transformers/TransformerConfig.ts rename to src/_archived/compiler/transformers/TransformerConfig.ts diff --git a/src/compiler/transformers/VariableDeclarationTransformer.ts b/src/_archived/compiler/transformers/VariableDeclarationTransformer.ts similarity index 100% rename from src/compiler/transformers/VariableDeclarationTransformer.ts rename to src/_archived/compiler/transformers/VariableDeclarationTransformer.ts diff --git a/src/compiler/transformers/default_config.ts b/src/_archived/compiler/transformers/default_config.ts similarity index 100% rename from src/compiler/transformers/default_config.ts rename to src/_archived/compiler/transformers/default_config.ts diff --git a/src/compiler/transformers/default_transformers.ts b/src/_archived/compiler/transformers/default_transformers.ts similarity index 100% rename from src/compiler/transformers/default_transformers.ts rename to src/_archived/compiler/transformers/default_transformers.ts diff --git a/src/compiler/utils.ts b/src/_archived/compiler/utils.ts similarity index 100% rename from src/compiler/utils.ts rename to src/_archived/compiler/utils.ts diff --git a/src/compiler/utils/generator.ts b/src/_archived/compiler/utils/generator.ts similarity index 100% rename from src/compiler/utils/generator.ts rename to src/_archived/compiler/utils/generator.ts diff --git a/src/config.ts b/src/_archived/config.ts similarity index 100% rename from src/config.ts rename to src/_archived/config.ts diff --git a/src/config/Config.ts b/src/_archived/config/Config.ts similarity index 100% rename from src/config/Config.ts rename to src/_archived/config/Config.ts diff --git a/src/config/default_config.ts b/src/_archived/config/default_config.ts similarity index 100% rename from src/config/default_config.ts rename to src/_archived/config/default_config.ts diff --git a/src/_archived/index.ts b/src/_archived/index.ts new file mode 100644 index 0000000..d5e7ab1 --- /dev/null +++ b/src/_archived/index.ts @@ -0,0 +1 @@ +export * from './transform'; diff --git a/src/lib/bundle.js b/src/_archived/lib/bundle.js similarity index 100% rename from src/lib/bundle.js rename to src/_archived/lib/bundle.js diff --git a/src/lib/implement.js b/src/_archived/lib/implement.js similarity index 100% rename from src/lib/implement.js rename to src/_archived/lib/implement.js diff --git a/src/lib/implements.js b/src/_archived/lib/implements.js similarity index 100% rename from src/lib/implements.js rename to src/_archived/lib/implements.js diff --git a/src/lib/index.js b/src/_archived/lib/index.js similarity index 100% rename from src/lib/index.js rename to src/_archived/lib/index.js diff --git a/src/lib/r.ts b/src/_archived/lib/r.ts similarity index 100% rename from src/lib/r.ts rename to src/_archived/lib/r.ts diff --git a/src/lib/t.ts b/src/_archived/lib/t.ts similarity index 100% rename from src/lib/t.ts rename to src/_archived/lib/t.ts diff --git a/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js new file mode 100644 index 0000000..6ec1e45 --- /dev/null +++ b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js @@ -0,0 +1 @@ +export { EventBus, bus } from './bus/Bus'; diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js similarity index 100% rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js rename to src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js similarity index 100% rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js rename to src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js diff --git a/src/playground/index.ts b/src/_archived/playground/index.ts similarity index 100% rename from src/playground/index.ts rename to src/_archived/playground/index.ts diff --git a/src/playground/package.json b/src/_archived/playground/package.json similarity index 100% rename from src/playground/package.json rename to src/_archived/playground/package.json diff --git a/src/playground/simple_example.ts b/src/_archived/playground/simple_example.ts similarity index 100% rename from src/playground/simple_example.ts rename to src/_archived/playground/simple_example.ts diff --git a/src/playground/test.js b/src/_archived/playground/test.js similarity index 100% rename from src/playground/test.js rename to src/_archived/playground/test.js diff --git a/src/playground/test.ts b/src/_archived/playground/test.ts similarity index 100% rename from src/playground/test.ts rename to src/_archived/playground/test.ts diff --git a/src/playground/test0.js b/src/_archived/playground/test0.js similarity index 100% rename from src/playground/test0.js rename to src/_archived/playground/test0.js diff --git a/src/playground/test0.ts b/src/_archived/playground/test0.ts similarity index 100% rename from src/playground/test0.ts rename to src/_archived/playground/test0.ts diff --git a/src/playground/test1.js b/src/_archived/playground/test1.js similarity index 100% rename from src/playground/test1.js rename to src/_archived/playground/test1.js diff --git a/src/playground/test1.ts b/src/_archived/playground/test1.ts similarity index 100% rename from src/playground/test1.ts rename to src/_archived/playground/test1.ts diff --git a/src/playground/test2.js b/src/_archived/playground/test2.js similarity index 100% rename from src/playground/test2.js rename to src/_archived/playground/test2.js diff --git a/src/playground/test2.ts b/src/_archived/playground/test2.ts similarity index 100% rename from src/playground/test2.ts rename to src/_archived/playground/test2.ts diff --git a/src/playground/test3.js b/src/_archived/playground/test3.js similarity index 100% rename from src/playground/test3.js rename to src/_archived/playground/test3.js diff --git a/src/playground/test3.ts b/src/_archived/playground/test3.ts similarity index 100% rename from src/playground/test3.ts rename to src/_archived/playground/test3.ts diff --git a/src/playground/test4.js b/src/_archived/playground/test4.js similarity index 100% rename from src/playground/test4.js rename to src/_archived/playground/test4.js diff --git a/src/playground/test4.ts b/src/_archived/playground/test4.ts similarity index 100% rename from src/playground/test4.ts rename to src/_archived/playground/test4.ts diff --git a/src/playground/yarn.lock b/src/_archived/playground/yarn.lock similarity index 100% rename from src/playground/yarn.lock rename to src/_archived/playground/yarn.lock diff --git a/src/test/config-2017-03-10_17-40-38-656.ts b/src/_archived/test/config-2017-03-10_17-40-38-656.ts similarity index 100% rename from src/test/config-2017-03-10_17-40-38-656.ts rename to src/_archived/test/config-2017-03-10_17-40-38-656.ts diff --git a/src/test/factory.ts b/src/_archived/test/factory.ts similarity index 100% rename from src/test/factory.ts rename to src/_archived/test/factory.ts diff --git a/src/test/source.js b/src/_archived/test/source.js similarity index 100% rename from src/test/source.js rename to src/_archived/test/source.js diff --git a/src/test/source.ts b/src/_archived/test/source.ts similarity index 100% rename from src/test/source.ts rename to src/_archived/test/source.ts diff --git a/src/test/test.ts b/src/_archived/test/test.ts similarity index 100% rename from src/test/test.ts rename to src/_archived/test/test.ts diff --git a/src/test/transformer.ts b/src/_archived/test/transformer.ts similarity index 100% rename from src/test/transformer.ts rename to src/_archived/test/transformer.ts diff --git a/src/test/v1.ts b/src/_archived/test/v1.ts similarity index 100% rename from src/test/v1.ts rename to src/_archived/test/v1.ts diff --git a/src/test/v2/.tsr/source.ts b/src/_archived/test/v2/.tsr/source.ts similarity index 100% rename from src/test/v2/.tsr/source.ts rename to src/_archived/test/v2/.tsr/source.ts diff --git a/src/test/v2/.tsr/source2.ts b/src/_archived/test/v2/.tsr/source2.ts similarity index 100% rename from src/test/v2/.tsr/source2.ts rename to src/_archived/test/v2/.tsr/source2.ts diff --git a/src/test/v2/.tsr/source3.ts b/src/_archived/test/v2/.tsr/source3.ts similarity index 100% rename from src/test/v2/.tsr/source3.ts rename to src/_archived/test/v2/.tsr/source3.ts diff --git a/src/test/v2/.tsr/source4.ts b/src/_archived/test/v2/.tsr/source4.ts similarity index 100% rename from src/test/v2/.tsr/source4.ts rename to src/_archived/test/v2/.tsr/source4.ts diff --git a/src/test/v2/source.js b/src/_archived/test/v2/source.js similarity index 100% rename from src/test/v2/source.js rename to src/_archived/test/v2/source.js diff --git a/src/test/v2/source.ts b/src/_archived/test/v2/source.ts similarity index 100% rename from src/test/v2/source.ts rename to src/_archived/test/v2/source.ts diff --git a/src/test/v2/source2.js b/src/_archived/test/v2/source2.js similarity index 100% rename from src/test/v2/source2.js rename to src/_archived/test/v2/source2.js diff --git a/src/test/v2/source2.ts b/src/_archived/test/v2/source2.ts similarity index 100% rename from src/test/v2/source2.ts rename to src/_archived/test/v2/source2.ts diff --git a/src/test/v2/source3.js b/src/_archived/test/v2/source3.js similarity index 100% rename from src/test/v2/source3.js rename to src/_archived/test/v2/source3.js diff --git a/src/test/v2/source3.ts b/src/_archived/test/v2/source3.ts similarity index 100% rename from src/test/v2/source3.ts rename to src/_archived/test/v2/source3.ts diff --git a/src/test/v2/source4.js b/src/_archived/test/v2/source4.js similarity index 100% rename from src/test/v2/source4.js rename to src/_archived/test/v2/source4.js diff --git a/src/test/v2/source4.ts b/src/_archived/test/v2/source4.ts similarity index 100% rename from src/test/v2/source4.ts rename to src/_archived/test/v2/source4.ts diff --git a/src/test/v2/test.ts b/src/_archived/test/v2/test.ts similarity index 100% rename from src/test/v2/test.ts rename to src/_archived/test/v2/test.ts diff --git a/src/test/v2/test2.ts b/src/_archived/test/v2/test2.ts similarity index 100% rename from src/test/v2/test2.ts rename to src/_archived/test/v2/test2.ts diff --git a/src/test/v2/transform.old.ts b/src/_archived/test/v2/transform.old.ts similarity index 100% rename from src/test/v2/transform.old.ts rename to src/_archived/test/v2/transform.old.ts diff --git a/src/_archived/transform.ts b/src/_archived/transform.ts new file mode 100644 index 0000000..79b588c --- /dev/null +++ b/src/_archived/transform.ts @@ -0,0 +1,36 @@ +import * as ts from 'typescript'; +import { Compiler, CompilerResult, CompilerConfig } from './compiler'; +import { Config, DEFAULT_CONFIG } from './config'; +import { bus } from './bus'; + +export function transform(files?: string | string[], config: Config = {}): Promise<CompilerResult> { + config = getConfig(config); + config.files = getFiles(files || config.files); + + bus.emit('main.start', config.files); + + return new Compiler(config) + .process() + .then(transformerResult => { + bus.emit('main.done', config.files); + return transformerResult; + }); +} + +function getConfig(config: Config = {}): Config { + return Object.assign({}, DEFAULT_CONFIG, config); +} + +function getFiles(files: string | string[]): string[] { + if (typeof files === 'string') { + files = [files]; + } + + if (!Array.isArray(files)) { + bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.')); + } + + return files as string[]; +} + +export default transform; diff --git a/src/writer.ts b/src/_archived/writer.ts similarity index 100% rename from src/writer.ts rename to src/_archived/writer.ts diff --git a/src/writer/Writer.ts b/src/_archived/writer/Writer.ts similarity index 100% rename from src/writer/Writer.ts rename to src/_archived/writer/Writer.ts diff --git a/src/writer/WriterConfig.ts b/src/_archived/writer/WriterConfig.ts similarity index 100% rename from src/writer/WriterConfig.ts rename to src/_archived/writer/WriterConfig.ts diff --git a/src/writer/WriterResult.ts b/src/_archived/writer/WriterResult.ts similarity index 100% rename from src/writer/WriterResult.ts rename to src/_archived/writer/WriterResult.ts diff --git a/src/writer/default_config.ts b/src/_archived/writer/default_config.ts similarity index 100% rename from src/writer/default_config.ts rename to src/_archived/writer/default_config.ts diff --git a/src/bus.ts b/src/bus.ts index 6ec1e45..602cfbd 100644 --- a/src/bus.ts +++ b/src/bus.ts @@ -1 +1,28 @@ -export { EventBus, bus } from './bus/Bus'; +import * as EventEmitter from 'events'; + +export const events = { + START: Symbol('start'), + END: Symbol('end'), + DIAGNOSTICS: Symbol('ts.diagnostics'), + DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'), + DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'), + DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'), + DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'), + DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'), + DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'), + TRANSFORM_START: Symbol('transform.start'), + TRANSFORM_END: Symbol('transform.end'), + // TRANSFORM_ERROR: Symbol('transform.error'), + WRITE_START: Symbol('write.start'), + WRITE_END: Symbol('write.end'), + WRITE_FILE_START: Symbol('write.file.start'), + WRITE_FILE_END: Symbol('write.file.end'), + // WRITE_ERROR: Symbol('write.error'), + EMIT_START: Symbol('emit.start'), + EMIT_END: Symbol('emit.end'), + // EMIT_ERROR: Symbol('emit.error'), + TEMP_DELETE_START: Symbol('temp.delete.start'), + TEMP_DELETE_END: Symbol('temp.delete.end'), +}; + +export const emitter = new EventEmitter(); diff --git a/src/next/context.ts b/src/context.ts similarity index 99% rename from src/next/context.ts rename to src/context.ts index 0b3a6dd..5e96159 100644 --- a/src/next/context.ts +++ b/src/context.ts @@ -67,6 +67,7 @@ export class MutationContext { return ''; } + // TODO: primitive types fail sometimes public getImplicitTypeNode(node: ts.Node): ts.TypeNode { let type = this.checker.getTypeAtLocation(node); let typeString = this.checker.typeToString(type); diff --git a/src/next/generator.ts b/src/generator.ts similarity index 100% rename from src/next/generator.ts rename to src/generator.ts diff --git a/src/index.ts b/src/index.ts index d5e7ab1..718adf2 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1 +1,8 @@ +import * as bus from './bus'; +import * as util from './util'; + +export { bus, util }; +export * from './context'; +export * from './mutators'; +export * from './options'; export * from './transform'; diff --git a/src/next/mutators.ts b/src/mutators.ts similarity index 79% rename from src/next/mutators.ts rename to src/mutators.ts index 1d7b6dc..4baf69a 100644 --- a/src/next/mutators.ts +++ b/src/mutators.ts @@ -1,9 +1,15 @@ import { Mutator } from './mutators/Mutator'; - import { BinaryExpressionMutator } from './mutators/BinaryExpressionMutator'; import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator'; import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator'; +export { + Mutator, + BinaryExpressionMutator, + InterfaceDeclarationMutator, + VariableDeclarationListMutator +}; + export const mutators: Mutator[] = [ new BinaryExpressionMutator(), new InterfaceDeclarationMutator(), diff --git a/src/next/mutators/BinaryExpressionMutator.ts b/src/mutators/BinaryExpressionMutator.ts similarity index 100% rename from src/next/mutators/BinaryExpressionMutator.ts rename to src/mutators/BinaryExpressionMutator.ts diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/mutators/InterfaceDeclararionMutator.ts similarity index 100% rename from src/next/mutators/InterfaceDeclararionMutator.ts rename to src/mutators/InterfaceDeclararionMutator.ts diff --git a/src/next/mutators/Mutator.ts b/src/mutators/Mutator.ts similarity index 100% rename from src/next/mutators/Mutator.ts rename to src/mutators/Mutator.ts diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/mutators/VariableDeclarationListMutator.ts similarity index 97% rename from src/next/mutators/VariableDeclarationListMutator.ts rename to src/mutators/VariableDeclarationListMutator.ts index c18daab..07187b8 100644 --- a/src/next/mutators/VariableDeclarationListMutator.ts +++ b/src/mutators/VariableDeclarationListMutator.ts @@ -102,7 +102,11 @@ export class VariableDeclarationListMutator extends Mutator { private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { const nodeName = this.context.getTypeDeclarationName(node.name.getText()); + + console.log(node.name.getText()); const implicitType = this.context.getImplicitTypeNode(node.name); + console.log(ts.SyntaxKind[implicitType.kind]); + console.log('\n'); if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) { return [node]; diff --git a/src/next/bus.ts b/src/next/bus.ts deleted file mode 100644 index 602cfbd..0000000 --- a/src/next/bus.ts +++ /dev/null @@ -1,28 +0,0 @@ -import * as EventEmitter from 'events'; - -export const events = { - START: Symbol('start'), - END: Symbol('end'), - DIAGNOSTICS: Symbol('ts.diagnostics'), - DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'), - DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'), - DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'), - DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'), - DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'), - DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'), - TRANSFORM_START: Symbol('transform.start'), - TRANSFORM_END: Symbol('transform.end'), - // TRANSFORM_ERROR: Symbol('transform.error'), - WRITE_START: Symbol('write.start'), - WRITE_END: Symbol('write.end'), - WRITE_FILE_START: Symbol('write.file.start'), - WRITE_FILE_END: Symbol('write.file.end'), - // WRITE_ERROR: Symbol('write.error'), - EMIT_START: Symbol('emit.start'), - EMIT_END: Symbol('emit.end'), - // EMIT_ERROR: Symbol('emit.error'), - TEMP_DELETE_START: Symbol('temp.delete.start'), - TEMP_DELETE_END: Symbol('temp.delete.end'), -}; - -export const emitter = new EventEmitter(); diff --git a/src/next/index.ts b/src/next/index.ts deleted file mode 100644 index 85a7872..0000000 --- a/src/next/index.ts +++ /dev/null @@ -1,10 +0,0 @@ -import * as b from './bus'; -export const bus = b; - -import * as u from './util'; -export const util = u; - -export * from './context'; -export * from './mutators'; -export * from './options'; -export * from './transform'; diff --git a/src/next/transform.ts b/src/next/transform.ts deleted file mode 100644 index 72a9982..0000000 --- a/src/next/transform.ts +++ /dev/null @@ -1,338 +0,0 @@ -import * as path from 'path'; -import * as rimraf from 'rimraf'; -import * as ts from 'typescript'; -import * as util from './util'; -import * as bus from './bus'; -import { MutationContext } from './context'; -import { mutators } from './mutators'; -import { Options, defaultOptions } from './options'; - -const DEBUG = false; - -export function transform(entryFile: string, options?: Options) { - options = getOptions(options); - - let host: ts.CompilerHost; - let program: ts.Program; - - startTransformation(); - - function startTransformation(): void { - notify(bus.events.START, { entryFile, options }); - - const basePath = path.dirname(entryFile); - - host = ts.createCompilerHost(options.compilerOptions); - program = ts.createProgram([entryFile], options.compilerOptions, host); - - const diagnostics: ts.Diagnostic[] = []; - - diagnostics.push(...program.getOptionsDiagnostics()); - diagnostics.push(...program.getGlobalDiagnostics()); - - for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { - diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); - diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); - } - - if (!check(diagnostics)) { - notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); - } - - const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); - - notify(bus.events.TRANSFORM_START, { sourceFiles }); - const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); - notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); - - if (!check(result.diagnostics)) { - notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); - notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); - } - - const printerOptions: ts.PrinterOptions = { - target: options.compilerOptions.target, - removeComments: false - }; - - const printHandlers: ts.PrintHandlers = { - substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node { - return node; - } - }; - - notify(bus.events.WRITE_START, { count: result.transformed.length }); - const printer = ts.createPrinter(printerOptions, printHandlers); - - let count = 0; - for (let transformed of result.transformed) { - count++; - const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); - const source = printer.printFile(transformed); - notify(bus.events.WRITE_FILE_START, { location, transformed, source }); - ts.sys.writeFile(location, source); - notify(bus.events.WRITE_FILE_END, { location, transformed, source }); - } - - notify(bus.events.WRITE_END, { count }); - - result.dispose(); - - emit(); - - if (!options.keepTempFiles) { - const tempPath = getTempPath(basePath, options.tempFolderName); - notify(bus.events.TEMP_DELETE_START, { tempPath }); - rimraf.sync(getTempPath(basePath, options.tempFolderName)); - notify(bus.events.TEMP_DELETE_END, { tempPath }); - } - - notify(bus.events.END, { entryFile, options }); - } - - function emit() { - const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); - notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); - - options.compilerOptions.outDir = path.dirname(entryFile); - - host = ts.createCompilerHost(options.compilerOptions); - program = ts.createProgram([tempEntryFile], options.compilerOptions, host); - - const diagnostics: ts.Diagnostic[] = []; - - diagnostics.push(...program.getOptionsDiagnostics()); - diagnostics.push(...program.getGlobalDiagnostics()); - - for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { - diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); - diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); - } - - - if (!check(diagnostics)) { - notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); - notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); - } - - const emitResult = program.emit(); - - if (!check(emitResult.diagnostics)) { - notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); - notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); - } - - notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); - } - - function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { - if (util.isKind(node, ts.SyntaxKind.SourceFile)) { - mc.setSourceFile(node); - } - - mc.setTransformationContext(tc); - mc.setScope(util.getScope(node)); - - return node; - } - - function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { - mc.addVisited(node); - return node; - } - - // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void { - // if (!node) return; - // let checker = program.getTypeChecker(); - // ts.forEachChild(node, n => { - // - // - // // let type = checker.getTypeAtLocation(n); - // // // console.log('TYPE', type); - // // let typeString = checker.typeToString(type); - // // console.log('TYPESTRING', typeString); - // // let source = `let temp: ${typeString};`; - // // console.log('SRC', source); - // // console.log('\n\n\n'); - // // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); - // // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; - // - // switch (n.kind) { - // case ts.SyntaxKind.BinaryExpression: - // // console.log((n as ts.BinaryExpression).getText()); - // // let s = program.getTypeChecker().getSymbolAtLocation(n); - // // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression); - // // console.log(s); - // // console.log(t); - // // console.log('\n\n'); - // break; - // case ts.SyntaxKind.Identifier: - // console.log((n as ts.Identifier).text); - // console.log('-----------------------'); - // - // - // - // // let t = checker.getTypeAtLocation(n); - // // // console.log(checker.getPropertiesOfType(t)); - // // // t = checker.getWidenedType(t); - // // // - // // console.log(ts.TypeFlags[t.flags]); - // - // let type = checker.getTypeAtLocation(n); - // - // let typeString = checker.typeToString(type); - // console.log(typeString); - // let source = `let temp: ${typeString};`; - // - // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); - // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; - // - // // - // // let asm = type.aliasSymbol; - // // - // // if (asm) { - // // if (asm.declarations && asm.declarations[0]) { - // // console.log(asm.declarations.length); - // // let asmi = asm.declarations[0] as ts.VariableDeclaration; - // // if (asmi.type) { - // // console.log('has type'); - // // console.log(ts.SyntaxKind[asmi.type.kind]); - // // } - // // } - // // } - // // - // console.log(ts.TypeFlags[type.flags]); - // console.log('\n\n'); - // - // // console.log('KIND:', (n as ts.Identifier).text); - // // console.log((n as ts.Identifier).originalKeywordKind); - // // console.log(''); - // - // // if (mc.names.indexOf((n as ts.Identifier).text) === -1) { - // // // mc.names.push((n as ts.Identifier).text); - // // // console.log('KIND:', (n as ts.Identifier).text); - // // // console.log((n as ts.Identifier).originalKeywordKind); - // // // console.log(''); - // // } - // break; - // case ts.SyntaxKind.VariableDeclaration: - // // const dec = n as ts.VariableDeclaration; - // // if (dec.name.kind === ts.SyntaxKind.Identifier) { - // // mc.declarations.set((dec.name as ts.Identifier).text, dec.type); - // // } - // break; - // } - // - // firstPassVisitor(n, mc, tc); - // }); - // } - - function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { - let mutationContext: MutationContext; - - const visitor: ts.Visitor = (node: ts.Node): ts.Node => { - if (node.kind === ts.SyntaxKind.SourceFile) { - mutationContext = new MutationContext(options, node as ts.SourceFile, program, host); - // firstPassVisitor(node as ts.SourceFile, mutationContext, context); - } - - // if (node.kind === ts.SyntaxKind.SourceFile) { - // console.log('---------------'); - // console.log('SourceFile'); - // console.log((node as ts.SourceFile).fileName); - // console.log('---------------\n\n'); - // } else { - // console.log(ts.SyntaxKind[node.kind]); - // } - - const parent = node.parent; - node = onBeforeVisit(node, mutationContext, context); - - if (DEBUG) { - const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; - console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); - console.log(`Scope: ${scope}`); - console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); - console.log(`File: ${mutationContext.sourceFile.fileName}`); - } - - for (let mutator of mutators) { - node = mutator.mutateNode(node, mutationContext); - } - - node.parent = parent; - util.setParent(node); - - if (DEBUG) { - console.log('<============================================'); - if (node.parent) { - if (node.flags === ts.NodeFlags.Synthesized) { - console.log('Cannot get text of synthesized node.'); - } else { - console.log(node.getText()); - } - } else { - console.log('Parent not set, cannot get text.'); - } - console.log('============================================>'); - } - - - if (DEBUG) { - console.log('\n\n'); - } - - node = onAfterVisit(node, mutationContext, context); - - return ts.visitEachChild(node, visitor, context); - }; - - return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); - } - - function getOptions(o: Options = {}): Options { - const opts = Object.assign({}, defaultOptions, o); - opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, o.compilerOptions || {}); - return opts; - } - - function getRootNames(rootNames: string | string[]): string[] { - if (Array.isArray(rootNames)) { - return rootNames; - } - - return [rootNames]; - } - - function getTempPath(basePath: string, tempFolderName: string): string { - return path.join(basePath, tempFolderName); - } - - function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { - const pathFromBase = path.dirname(file.replace(basePath, '')); - const tempPath = getTempPath(basePath, tempFolderName); - const fileName = path.basename(file); - - return path.join(tempPath, pathFromBase, fileName); - } - - function check(diagnostics: ts.Diagnostic[]): boolean { - if (diagnostics && diagnostics.length > 0) { - notify(bus.events.DIAGNOSTICS, { diagnostics }); - console.error(ts.formatDiagnostics(diagnostics, { - getCurrentDirectory: () => ts.sys.getCurrentDirectory(), - getNewLine: () => ts.sys.newLine, - getCanonicalFileName: (f: string) => f - })); - return false; - } - - return true; - } - - function notify(event: string | symbol, ...args: any[]): boolean { - return bus.emitter.emit(event, args); - } - -} diff --git a/src/next/options.ts b/src/options.ts similarity index 100% rename from src/next/options.ts rename to src/options.ts diff --git a/src/package.json b/src/package.json deleted file mode 100644 index ca9e77d..0000000 --- a/src/package.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "dependencies": { - "ora": "^1.1.0" - } -} diff --git a/src/playground/run.ts b/src/playground/run.ts new file mode 100644 index 0000000..189bd12 --- /dev/null +++ b/src/playground/run.ts @@ -0,0 +1,6 @@ +import * as path from 'path'; +import * as tsr from '../'; + +tsr.transform(path.join(__dirname, './snippets/source4.ts'), { + compilerOptions: {} +}); diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts new file mode 100644 index 0000000..decbfde --- /dev/null +++ b/src/playground/snippets/.tsr/source3.ts @@ -0,0 +1,35 @@ +export const bla = t.any().assert('bla'); +console.log(bla); +type TestType = { + name: string; +}; +const a: string = t.string().assert('hallo'); +let _bType = t.array(t.number()), b: number[]; +b = _bType.assert([10]); +function testFunction(t: TestType): string { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); +let hasAnyType: any; +hasAnyType = 55; +const constAny: any = 10; +function getX() { + return [1, 2, 3]; +} +let _aaaType = t.number(), aaa = _aaaType.assert(10); +const bbb = t.array(t.number()).assert(getX()); +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi: string; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +const z = t.any().assert('hhh'); +const h = t.array(t.number()).assert([1, 2]); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; +export const bla = t.array(t.number()).assert([10]); +const blub = t.any().assert('str'); +let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); +x = _xType.assert(5); diff --git a/src/playground/snippets/.tsr/source4.ts b/src/playground/snippets/.tsr/source4.ts new file mode 100644 index 0000000..e58abd9 --- /dev/null +++ b/src/playground/snippets/.tsr/source4.ts @@ -0,0 +1,24 @@ +import { bla } from './source3'; +console.log(bla); +type TestType = { + name: string; +}; +const a: string = t.string().assert('hallo'); +let _bType = t.array(t.number()), b: number[]; +b = _bType.assert([10]); +function testFunction(t: TestType): string { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); +let hasAnyType: any; +hasAnyType = 55; +const constAny: any = 10; +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi: string; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; diff --git a/src/playground/snippets/source1.ts b/src/playground/snippets/source1.ts new file mode 100644 index 0000000..4a84eb7 --- /dev/null +++ b/src/playground/snippets/source1.ts @@ -0,0 +1,15 @@ +import { a, TestInterface } from './source2'; +import { bla } from './source3'; + +console.log(a); +console.log(bla); +console.log(TestInterface); + +class Test implements TestInterface { + + public test(): string { + let a = 'hi'; + return a; + } + +} diff --git a/src/playground/snippets/source2.ts b/src/playground/snippets/source2.ts new file mode 100644 index 0000000..888f0ea --- /dev/null +++ b/src/playground/snippets/source2.ts @@ -0,0 +1,5 @@ +export interface TestInterface { + +} + +export const a = 'hi'; diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js new file mode 100644 index 0000000..84bd5ba --- /dev/null +++ b/src/playground/snippets/source3.js @@ -0,0 +1,32 @@ +export const bla = t.any().assert('bla'); +console.log(bla); +const a = t.string().assert('hallo'); +let _bType = t.array(t.number()), b; +b = _bType.assert([10]); +function testFunction(t) { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); +let hasAnyType; +hasAnyType = 55; +const constAny = 10; +function getX() { + return [1, 2, 3]; +} +let _aaaType = t.number(), aaa = _aaaType.assert(10); +const bbb = t.array(t.number()).assert(getX()); +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +const z = t.any().assert('hhh'); +const h = t.array(t.number()).assert([1, 2]); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; +export const bla = t.array(t.number()).assert([10]); +const blub = t.any().assert('str'); +let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); +x = _xType.assert(5); diff --git a/src/playground/snippets/source3.ts b/src/playground/snippets/source3.ts new file mode 100644 index 0000000..5f34ef6 --- /dev/null +++ b/src/playground/snippets/source3.ts @@ -0,0 +1,55 @@ +export const bla = 'bla'; + +console.log(bla); + +type TestType = { + name: string; +}; + +const a: string = 'hallo'; +let b: number[]; +b = [10]; + +function testFunction(t: TestType): string { + return 'Hello ' + t.name; +} + +console.log(testFunction({name: 'Alice'})); + +let hasAnyType: any; +hasAnyType = 55; + +const constAny: any = 10; + +function getX() { + return [1, 2, 3]; +} + +let aaa = 10; +const bbb = getX(); +let x = [5, 10]; + +let hasNoType; +hasNoType = 5; + +var hi: string; + +hi = console; + +const y = ['hallo', 'du']; + +const z = 'hhh'; +const h = [1, 2]; + +x = 5; +x = 'hi'; +hasNoType = 'str'; + +export const bla = [10]; + +const blub = 'str'; + +let wefkh = 111; + + +x = 5; diff --git a/src/playground/snippets/source4.js b/src/playground/snippets/source4.js new file mode 100644 index 0000000..838722f --- /dev/null +++ b/src/playground/snippets/source4.js @@ -0,0 +1,21 @@ +import { bla } from './source3'; +console.log(bla); +const a = t.string().assert('hallo'); +let _bType = t.array(t.number()), b; +b = _bType.assert([10]); +function testFunction(t) { + return 'Hello ' + t.name; +} +console.log(testFunction({ name: 'Alice' })); +let hasAnyType; +hasAnyType = 55; +const constAny = 10; +let _xType = t.array(t.number()), x = _xType.assert([5, 10]); +let hasNoType; +hasNoType = 5; +var _hiType = t.string(), hi; +hi = _hiType.assert(console); +const y = t.array(t.string()).assert(['hallo', 'du']); +x = _xType.assert(5); +x = _xType.assert('hi'); +hasNoType = 'str'; diff --git a/src/playground/snippets/source4.ts b/src/playground/snippets/source4.ts new file mode 100644 index 0000000..e3fee78 --- /dev/null +++ b/src/playground/snippets/source4.ts @@ -0,0 +1,37 @@ +import { bla } from './source3'; + +console.log(bla); + +type TestType = { + name: string; +}; + +const a: string = 'hallo'; +let b: number[]; +b = [10]; + +function testFunction(t: TestType): string { + return 'Hello ' + t.name; +} + +console.log(testFunction({name: 'Alice'})); + +let hasAnyType: any; +hasAnyType = 55; + +const constAny: any = 10; + +let x = [5, 10]; + +let hasNoType; +hasNoType = 5; + +var hi: string; + +hi = console; + +const y = ['hallo', 'du']; + +x = 5; +x = 'hi'; +hasNoType = 'str'; diff --git a/src/transform.ts b/src/transform.ts index 79b588c..bb212a3 100644 --- a/src/transform.ts +++ b/src/transform.ts @@ -1,36 +1,338 @@ +import * as path from 'path'; +import * as rimraf from 'rimraf'; import * as ts from 'typescript'; -import { Compiler, CompilerResult, CompilerConfig } from './compiler'; -import { Config, DEFAULT_CONFIG } from './config'; -import { bus } from './bus'; - -export function transform(files?: string | string[], config: Config = {}): Promise<CompilerResult> { - config = getConfig(config); - config.files = getFiles(files || config.files); - - bus.emit('main.start', config.files); - - return new Compiler(config) - .process() - .then(transformerResult => { - bus.emit('main.done', config.files); - return transformerResult; - }); +import * as util from './util'; +import * as bus from './bus'; +import { MutationContext } from './context'; +import { mutators } from './mutators'; +import { Options, defaultOptions } from './options'; + +const DEBUG = false; + +export function transform(entryFile: string, options?: Options) { + options = getOptions(options); + + let host: ts.CompilerHost; + let program: ts.Program; + + startTransformation(); + + function startTransformation(): void { + notify(bus.events.START, { entryFile, options }); + + const basePath = path.dirname(entryFile); + + host = ts.createCompilerHost(options.compilerOptions, true); + program = ts.createProgram([entryFile], options.compilerOptions, host); + + const diagnostics: ts.Diagnostic[] = []; + + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + } + + if (!check(diagnostics)) { + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics }); + } + + const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile); + + notify(bus.events.TRANSFORM_START, { sourceFiles }); + const result = ts.transform(sourceFiles, [transformer], options.compilerOptions); + notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed }); + + if (!check(result.diagnostics)) { + notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics }); + notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics }); + } + + const printerOptions: ts.PrinterOptions = { + target: options.compilerOptions.target, + removeComments: false + }; + + const printHandlers: ts.PrintHandlers = { + substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node { + return node; + } + }; + + notify(bus.events.WRITE_START, { count: result.transformed.length }); + const printer = ts.createPrinter(printerOptions, printHandlers); + + let count = 0; + for (let transformed of result.transformed) { + count++; + const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName); + const source = printer.printFile(transformed); + notify(bus.events.WRITE_FILE_START, { location, transformed, source }); + ts.sys.writeFile(location, source); + notify(bus.events.WRITE_FILE_END, { location, transformed, source }); + } + + notify(bus.events.WRITE_END, { count }); + + result.dispose(); + + emit(); + + if (!options.keepTempFiles) { + const tempPath = getTempPath(basePath, options.tempFolderName); + notify(bus.events.TEMP_DELETE_START, { tempPath }); + rimraf.sync(getTempPath(basePath, options.tempFolderName)); + notify(bus.events.TEMP_DELETE_END, { tempPath }); + } + + notify(bus.events.END, { entryFile, options }); + } + + function emit() { + const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); + notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); + + options.compilerOptions.outDir = path.dirname(entryFile); + + host = ts.createCompilerHost(options.compilerOptions); + program = ts.createProgram([tempEntryFile], options.compilerOptions, host); + + const diagnostics: ts.Diagnostic[] = []; + + diagnostics.push(...program.getOptionsDiagnostics()); + diagnostics.push(...program.getGlobalDiagnostics()); + + for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) { + diagnostics.push(...program.getSyntacticDiagnostics(sourceFile)); + diagnostics.push(...program.getSemanticDiagnostics(sourceFile)); + } + + + if (!check(diagnostics)) { + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics }); + } + + const emitResult = program.emit(); + + if (!check(emitResult.diagnostics)) { + notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics }); + notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics }); + } + + notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options }); + } + + function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + if (util.isKind(node, ts.SyntaxKind.SourceFile)) { + mc.setSourceFile(node); + } + + mc.setTransformationContext(tc); + mc.setScope(util.getScope(node)); + + return node; + } + + function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { + mc.addVisited(node); + return node; + } + + // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void { + // if (!node) return; + // let checker = program.getTypeChecker(); + // ts.forEachChild(node, n => { + // + // + // // let type = checker.getTypeAtLocation(n); + // // // console.log('TYPE', type); + // // let typeString = checker.typeToString(type); + // // console.log('TYPESTRING', typeString); + // // let source = `let temp: ${typeString};`; + // // console.log('SRC', source); + // // console.log('\n\n\n'); + // // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); + // // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; + // + // switch (n.kind) { + // case ts.SyntaxKind.BinaryExpression: + // // console.log((n as ts.BinaryExpression).getText()); + // // let s = program.getTypeChecker().getSymbolAtLocation(n); + // // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression); + // // console.log(s); + // // console.log(t); + // // console.log('\n\n'); + // break; + // case ts.SyntaxKind.Identifier: + // console.log((n as ts.Identifier).text); + // console.log('-----------------------'); + // + // + // + // // let t = checker.getTypeAtLocation(n); + // // // console.log(checker.getPropertiesOfType(t)); + // // // t = checker.getWidenedType(t); + // // // + // // console.log(ts.TypeFlags[t.flags]); + // + // let type = checker.getTypeAtLocation(n); + // + // let typeString = checker.typeToString(type); + // console.log(typeString); + // let source = `let temp: ${typeString};`; + // + // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); + // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; + // + // // + // // let asm = type.aliasSymbol; + // // + // // if (asm) { + // // if (asm.declarations && asm.declarations[0]) { + // // console.log(asm.declarations.length); + // // let asmi = asm.declarations[0] as ts.VariableDeclaration; + // // if (asmi.type) { + // // console.log('has type'); + // // console.log(ts.SyntaxKind[asmi.type.kind]); + // // } + // // } + // // } + // // + // console.log(ts.TypeFlags[type.flags]); + // console.log('\n\n'); + // + // // console.log('KIND:', (n as ts.Identifier).text); + // // console.log((n as ts.Identifier).originalKeywordKind); + // // console.log(''); + // + // // if (mc.names.indexOf((n as ts.Identifier).text) === -1) { + // // // mc.names.push((n as ts.Identifier).text); + // // // console.log('KIND:', (n as ts.Identifier).text); + // // // console.log((n as ts.Identifier).originalKeywordKind); + // // // console.log(''); + // // } + // break; + // case ts.SyntaxKind.VariableDeclaration: + // // const dec = n as ts.VariableDeclaration; + // // if (dec.name.kind === ts.SyntaxKind.Identifier) { + // // mc.declarations.set((dec.name as ts.Identifier).text, dec.type); + // // } + // break; + // } + // + // firstPassVisitor(n, mc, tc); + // }); + // } + + function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { + let mutationContext: MutationContext; + + const visitor: ts.Visitor = (node: ts.Node): ts.Node => { + if (node.kind === ts.SyntaxKind.SourceFile) { + mutationContext = new MutationContext(options, node as ts.SourceFile, program, host); + // firstPassVisitor(node as ts.SourceFile, mutationContext, context); + } + + // if (node.kind === ts.SyntaxKind.SourceFile) { + // console.log('---------------'); + // console.log('SourceFile'); + // console.log((node as ts.SourceFile).fileName); + // console.log('---------------\n\n'); + // } else { + // console.log(ts.SyntaxKind[node.kind]); + // } + + const parent = node.parent; + node = onBeforeVisit(node, mutationContext, context); + + if (DEBUG) { + const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; + console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); + console.log(`Scope: ${scope}`); + console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); + console.log(`File: ${mutationContext.sourceFile.fileName}`); + } + + for (let mutator of mutators) { + node = mutator.mutateNode(node, mutationContext); + } + + node.parent = parent; + util.setParent(node); + + if (DEBUG) { + console.log('<============================================'); + if (node.parent) { + if (node.flags === ts.NodeFlags.Synthesized) { + console.log('Cannot get text of synthesized node.'); + } else { + console.log(node.getText()); + } + } else { + console.log('Parent not set, cannot get text.'); + } + console.log('============================================>'); + } + + + if (DEBUG) { + console.log('\n\n'); + } + + node = onAfterVisit(node, mutationContext, context); + + return ts.visitEachChild(node, visitor, context); + }; + + return (sf: ts.SourceFile) => ts.visitNode(sf, visitor); + } + } -function getConfig(config: Config = {}): Config { - return Object.assign({}, DEFAULT_CONFIG, config); +export function getOptions(options: Options = {}): Options { + const opts = Object.assign({}, defaultOptions, options); + opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {}); + return opts; } -function getFiles(files: string | string[]): string[] { - if (typeof files === 'string') { - files = [files]; +function getRootNames(rootNames: string | string[]): string[] { + if (Array.isArray(rootNames)) { + return rootNames; } - if (!Array.isArray(files)) { - bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.')); + return [rootNames]; +} + +function getTempPath(basePath: string, tempFolderName: string): string { + return path.join(basePath, tempFolderName); +} + +function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { + const pathFromBase = path.dirname(file.replace(basePath, '')); + const tempPath = getTempPath(basePath, tempFolderName); + const fileName = path.basename(file); + + return path.join(tempPath, pathFromBase, fileName); +} + +function check(diagnostics: ts.Diagnostic[]): boolean { + if (diagnostics && diagnostics.length > 0) { + notify(bus.events.DIAGNOSTICS, { diagnostics }); + console.error(ts.formatDiagnostics(diagnostics, { + getCurrentDirectory: () => ts.sys.getCurrentDirectory(), + getNewLine: () => ts.sys.newLine, + getCanonicalFileName: (f: string) => f + })); + return false; } - return files as string[]; + return true; } -export default transform; +function notify(event: string | symbol, ...args: any[]): boolean { + return bus.emitter.emit(event, args); +} diff --git a/src/next/util.ts b/src/util.ts similarity index 100% rename from src/next/util.ts rename to src/util.ts diff --git a/src/yarn.lock b/src/yarn.lock deleted file mode 100644 index 0656dce..0000000 --- a/src/yarn.lock +++ /dev/null @@ -1,87 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - -ansi-regex@^2.0.0: - version "2.1.1" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df" - -ansi-styles@^2.2.1: - version "2.2.1" - resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe" - -chalk@^1.0.0, chalk@^1.1.1: - version "1.1.3" - resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98" - dependencies: - ansi-styles "^2.2.1" - escape-string-regexp "^1.0.2" - has-ansi "^2.0.0" - strip-ansi "^3.0.0" - supports-color "^2.0.0" - -cli-cursor@^2.1.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5" - dependencies: - restore-cursor "^2.0.0" - -cli-spinners@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-1.0.0.tgz#ef987ed3d48391ac3dab9180b406a742180d6e6a" - -escape-string-regexp@^1.0.2: - version "1.0.5" - resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" - -has-ansi@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91" - dependencies: - ansi-regex "^2.0.0" - -log-symbols@^1.0.2: - version "1.0.2" - resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-1.0.2.tgz#376ff7b58ea3086a0f09facc74617eca501e1a18" - dependencies: - chalk "^1.0.0" - -mimic-fn@^1.0.0: - version "1.1.0" - resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.1.0.tgz#e667783d92e89dbd342818b5230b9d62a672ad18" - -onetime@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.0.tgz#52aa8110e52fc5126ffc667bd8ec21c2ed209ce6" - dependencies: - mimic-fn "^1.0.0" - -ora@^1.1.0: - version "1.1.0" - resolved "https://registry.yarnpkg.com/ora/-/ora-1.1.0.tgz#69aaa4a209630e43b142c5f7ff41820da87e2faf" - dependencies: - chalk "^1.1.1" - cli-cursor "^2.1.0" - cli-spinners "^1.0.0" - log-symbols "^1.0.2" - -restore-cursor@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf" - dependencies: - onetime "^2.0.0" - signal-exit "^3.0.2" - -signal-exit@^3.0.2: - version "3.0.2" - resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d" - -strip-ansi@^3.0.0: - version "3.0.1" - resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf" - dependencies: - ansi-regex "^2.0.0" - -supports-color@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7" From bde9a8e704907a89d82adf6085223ba7aeeda0b5 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 16 Mar 2017 23:42:37 +0100 Subject: [PATCH 19/26] Identified missing type generators. --- src/context.ts | 2 +- src/generator.ts | 4 ++-- src/playground/snippets/.tsr/source3.ts | 6 +++--- src/playground/snippets/source3.js | 6 +++--- src/util.ts | 4 ++++ 5 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/context.ts b/src/context.ts index 5e96159..4419bb8 100644 --- a/src/context.ts +++ b/src/context.ts @@ -67,7 +67,7 @@ export class MutationContext { return ''; } - // TODO: primitive types fail sometimes + // TODO: handle LastTypeNode (and FirstTypeNode) public getImplicitTypeNode(node: ts.Node): ts.TypeNode { let type = this.checker.getTypeAtLocation(node); let typeString = this.checker.typeToString(type); diff --git a/src/generator.ts b/src/generator.ts index dc7f10c..4e89b89 100644 --- a/src/generator.ts +++ b/src/generator.ts @@ -22,7 +22,7 @@ export function typeAssertion(id: string | ts.Expression, args: ts.Expression | return propertyAccessCall(id, 'assert', args, types); } -// TODO: Add ParenthesizedType (among others) +// TODO: Add ParenthesizedType, LiteralType,... export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { if (!type) { return null; @@ -82,7 +82,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { } default: { - return propertyAccessCall(LIB, 'any'); + return propertyAccessCall(LIB, 'unknown'); } } } diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts index decbfde..9b3372c 100644 --- a/src/playground/snippets/.tsr/source3.ts +++ b/src/playground/snippets/.tsr/source3.ts @@ -1,4 +1,4 @@ -export const bla = t.any().assert('bla'); +export const bla = t.unknown().assert('bla'); console.log(bla); type TestType = { name: string; @@ -24,12 +24,12 @@ hasNoType = 5; var _hiType = t.string(), hi: string; hi = _hiType.assert(console); const y = t.array(t.string()).assert(['hallo', 'du']); -const z = t.any().assert('hhh'); +const z = t.unknown().assert('hhh'); const h = t.array(t.number()).assert([1, 2]); x = _xType.assert(5); x = _xType.assert('hi'); hasNoType = 'str'; export const bla = t.array(t.number()).assert([10]); -const blub = t.any().assert('str'); +const blub = t.unknown().assert('str'); let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); x = _xType.assert(5); diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js index 84bd5ba..9e56a45 100644 --- a/src/playground/snippets/source3.js +++ b/src/playground/snippets/source3.js @@ -1,4 +1,4 @@ -export const bla = t.any().assert('bla'); +export const bla = t.unknown().assert('bla'); console.log(bla); const a = t.string().assert('hallo'); let _bType = t.array(t.number()), b; @@ -21,12 +21,12 @@ hasNoType = 5; var _hiType = t.string(), hi; hi = _hiType.assert(console); const y = t.array(t.string()).assert(['hallo', 'du']); -const z = t.any().assert('hhh'); +const z = t.unknown().assert('hhh'); const h = t.array(t.number()).assert([1, 2]); x = _xType.assert(5); x = _xType.assert('hi'); hasNoType = 'str'; export const bla = t.array(t.number()).assert([10]); -const blub = t.any().assert('str'); +const blub = t.unknown().assert('str'); let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); x = _xType.assert(5); diff --git a/src/util.ts b/src/util.ts index 1c6c17a..efc1c68 100644 --- a/src/util.ts +++ b/src/util.ts @@ -20,6 +20,10 @@ export function getScope(node: ts.Node): ts.Node { return getScope(node.parent); } +export function isAnyOrLiteralKind(kind: ts.SyntaxKind): boolean { + return kind === ts.SyntaxKind.AnyKeyword || kind === ts.SyntaxKind.LiteralType; +} + // TODO: test export function identifierExistsUp(node: ts.Node, id: string | ts.Identifier) { if (typeof id !== 'string') id = id.text; From 3c8282e8e4edcc3770fc3861ee01fe13d1512ca7 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:31:08 +0100 Subject: [PATCH 20/26] Implemented more types. --- src/generator.ts | 81 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 78 insertions(+), 3 deletions(-) diff --git a/src/generator.ts b/src/generator.ts index 4e89b89..3d13555 100644 --- a/src/generator.ts +++ b/src/generator.ts @@ -14,7 +14,7 @@ export function typeDeclaration(name: string | ts.Identifier, type: string | ts. return ts.createVariableDeclaration(name, undefined, typeDefinition(type)); } -export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression { +export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression { return typeAssertion(typeDefinition(type), args, types); } @@ -23,7 +23,26 @@ export function typeAssertion(id: string | ts.Expression, args: ts.Expression | } // TODO: Add ParenthesizedType, LiteralType,... -export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { +// Array, Object and Function Destructuring +// Spread operator +// Default values +// Remove types in .tsr +// +// VoidKeyword (only undefined or null for variables) OK +// NeverKeyword +// EnumKeyword +// +// ParenthesizedType OK +// LiteralType +// UnionType OK +// +// TypePredicate +// ThisType OK +// TypeOperator +// IndexedAccessType +// MappedType +// TypeAliasDeclaration +export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { if (!type) { return null; } @@ -39,13 +58,68 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { case ts.SyntaxKind.NumberKeyword: case ts.SyntaxKind.StringKeyword: case ts.SyntaxKind.AnyKeyword: + case ts.SyntaxKind.NullKeyword: { return propertyAccessCall(LIB, type.getText()); } + case ts.SyntaxKind.SymbolKeyword: + { + return propertyAccessCall(LIB, 'ref', ts.createIdentifier('Symbol')); + } + case ts.SyntaxKind.UndefinedKeyword: + { + return propertyAccessCall(LIB, 'void'); + } + case ts.SyntaxKind.VoidKeyword: + { + return propertyAccessCall(LIB, 'union', [ + propertyAccessCall(LIB, 'void'), + propertyAccessCall(LIB, 'null') + ]); + } + case ts.SyntaxKind.ParenthesizedType: + { + return typeDefinition((type as ts.ParenthesizedTypeNode).type); + } + case ts.SyntaxKind.LiteralType: + { + const ltn = type as ts.LiteralTypeNode; + + switch (ltn.literal.kind) { + case ts.SyntaxKind.TrueKeyword: + return propertyAccessCall(LIB, 'boolean', ts.createTrue()); + case ts.SyntaxKind.FalseKeyword: + return propertyAccessCall(LIB, 'boolean', ts.createFalse()); + case ts.SyntaxKind.StringLiteral: + const str = ltn.literal.getText(); + return propertyAccessCall(LIB, 'string', ts.createLiteral(str.substring(1, str.length - 1))); + case ts.SyntaxKind.NumericLiteral: + return propertyAccessCall(LIB, 'number', ts.createNumericLiteral(ltn.literal.getText())); + default: + // TODO: Throw exception here? + { + const str = ltn.literal.getText(); + return propertyAccessCall(LIB, 'ref', ts.createIdentifier(str.substring(1, str.length - 1))); + } + } + } + case ts.SyntaxKind.ThisType: + { + return propertyAccessCall(LIB, 'this', ts.createThis()); + } + case ts.SyntaxKind.UnionType: + { + let args: ts.CallExpression[] = (type as ts.UnionTypeNode).types.map(typeNode => { + return typeDefinition(typeNode); + }); + + return propertyAccessCall(LIB, 'union', args); + } case ts.SyntaxKind.ArrayType: { const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode; const callExpression = propertyAccessCall(LIB, 'array', typeDefinition(typeNode)); + return callExpression; } case ts.SyntaxKind.TypeReference: @@ -56,7 +130,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { let callExpression: ts.CallExpression; if (typeRef.typeArguments) { - for (const arg of typeRef.typeArguments) { + for (let arg of typeRef.typeArguments) { args.push(typeDefinition(arg)); } } @@ -82,6 +156,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression { } default: { + // TODO: Throw exception, type cannot be classified. return propertyAccessCall(LIB, 'unknown'); } } From 7125b1425f07ea6531a03e9f4132fc1289fc45fd Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:31:24 +0100 Subject: [PATCH 21/26] Added .tsr to gitignore. --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index cdeda3e..b25819b 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ logs pids *.pid *.seed +.tsr From 6582d372142c5d0fc5bcd70b60a5076a881e4569 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:32:06 +0100 Subject: [PATCH 22/26] Minor improvements. --- src/context.ts | 43 +++------- src/transform.ts | 207 +++++++++++++++-------------------------------- src/util.ts | 2 + 3 files changed, 78 insertions(+), 174 deletions(-) diff --git a/src/context.ts b/src/context.ts index 4419bb8..aaee5e1 100644 --- a/src/context.ts +++ b/src/context.ts @@ -1,8 +1,6 @@ import * as ts from 'typescript'; import * as util from './util'; -import { Options } from './options'; - -export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock; +import { Options, defaultOptions } from './options'; export class MutationContext { @@ -11,18 +9,17 @@ export class MutationContext { private _program: ts.Program; private _checker: ts.TypeChecker; private _host: ts.CompilerHost; - private _scope: Scope; private _visited: ts.Node[]; private _transformationContext: ts.TransformationContext; - constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost) { + constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost, context: ts.TransformationContext) { this._options = options; this._sourceFile = sourceFile; this._program = program; this._checker = program.getTypeChecker(); this._host = host; - this._scope = sourceFile; this._visited = []; + this._transformationContext = context; } public wasVisited(node: ts.Node): boolean { @@ -68,14 +65,18 @@ export class MutationContext { } // TODO: handle LastTypeNode (and FirstTypeNode) - public getImplicitTypeNode(node: ts.Node): ts.TypeNode { - let type = this.checker.getTypeAtLocation(node); - let typeString = this.checker.typeToString(type); + public getImplicitTypeNode(node: string | ts.Node): ts.TypeNode { + const typeString = typeof node === 'string' ? node : this.getImplicitTypeText(node); let source = `let temp: ${typeString};`; - let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS); + let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || defaultOptions.compilerOptions.target, true, ts.ScriptKind.TS); return (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; } + public getImplicitTypeText(node: ts.Node): string { + const type = this.checker.getTypeAtLocation(node); + return this.checker.typeToString(type); + } + public getType(node: ts.Node): ts.Type { return this.checker.getTypeAtLocation(node); } @@ -106,28 +107,6 @@ export class MutationContext { return this._visited; } - get scope() { - return this._scope; - } - - set scope(node: ts.Node) { - switch (node.kind) { - case ts.SyntaxKind.SourceFile: - this._sourceFile = node as ts.SourceFile; - case ts.SyntaxKind.Block: - case ts.SyntaxKind.ModuleBlock: - case ts.SyntaxKind.CaseBlock: - this._scope = node as Scope; - break; - default: - throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`); - } - } - - public setScope(node: ts.Node): void { - this.scope = node; - } - get sourceFile() { return this._sourceFile; } diff --git a/src/transform.ts b/src/transform.ts index bb212a3..aa66ba7 100644 --- a/src/transform.ts +++ b/src/transform.ts @@ -7,7 +7,7 @@ import { MutationContext } from './context'; import { mutators } from './mutators'; import { Options, defaultOptions } from './options'; -const DEBUG = false; +const DEBUG = true; export function transform(entryFile: string, options?: Options) { options = getOptions(options); @@ -15,9 +15,7 @@ export function transform(entryFile: string, options?: Options) { let host: ts.CompilerHost; let program: ts.Program; - startTransformation(); - - function startTransformation(): void { + (function autoStartTransformation(): void { notify(bus.events.START, { entryFile, options }); const basePath = path.dirname(entryFile); @@ -79,7 +77,7 @@ export function transform(entryFile: string, options?: Options) { result.dispose(); - emit(); + emitTransformed(); if (!options.keepTempFiles) { const tempPath = getTempPath(basePath, options.tempFolderName); @@ -89,9 +87,9 @@ export function transform(entryFile: string, options?: Options) { } notify(bus.events.END, { entryFile, options }); - } + })(); - function emit() { + function emitTransformed() { const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName); notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options }); @@ -127,13 +125,6 @@ export function transform(entryFile: string, options?: Options) { } function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node { - if (util.isKind(node, ts.SyntaxKind.SourceFile)) { - mc.setSourceFile(node); - } - - mc.setTransformationContext(tc); - mc.setScope(util.getScope(node)); - return node; } @@ -142,120 +133,22 @@ export function transform(entryFile: string, options?: Options) { return node; } - // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void { - // if (!node) return; - // let checker = program.getTypeChecker(); - // ts.forEachChild(node, n => { - // - // - // // let type = checker.getTypeAtLocation(n); - // // // console.log('TYPE', type); - // // let typeString = checker.typeToString(type); - // // console.log('TYPESTRING', typeString); - // // let source = `let temp: ${typeString};`; - // // console.log('SRC', source); - // // console.log('\n\n\n'); - // // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); - // // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; - // - // switch (n.kind) { - // case ts.SyntaxKind.BinaryExpression: - // // console.log((n as ts.BinaryExpression).getText()); - // // let s = program.getTypeChecker().getSymbolAtLocation(n); - // // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression); - // // console.log(s); - // // console.log(t); - // // console.log('\n\n'); - // break; - // case ts.SyntaxKind.Identifier: - // console.log((n as ts.Identifier).text); - // console.log('-----------------------'); - // - // - // - // // let t = checker.getTypeAtLocation(n); - // // // console.log(checker.getPropertiesOfType(t)); - // // // t = checker.getWidenedType(t); - // // // - // // console.log(ts.TypeFlags[t.flags]); - // - // let type = checker.getTypeAtLocation(n); - // - // let typeString = checker.typeToString(type); - // console.log(typeString); - // let source = `let temp: ${typeString};`; - // - // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); - // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; - // - // // - // // let asm = type.aliasSymbol; - // // - // // if (asm) { - // // if (asm.declarations && asm.declarations[0]) { - // // console.log(asm.declarations.length); - // // let asmi = asm.declarations[0] as ts.VariableDeclaration; - // // if (asmi.type) { - // // console.log('has type'); - // // console.log(ts.SyntaxKind[asmi.type.kind]); - // // } - // // } - // // } - // // - // console.log(ts.TypeFlags[type.flags]); - // console.log('\n\n'); - // - // // console.log('KIND:', (n as ts.Identifier).text); - // // console.log((n as ts.Identifier).originalKeywordKind); - // // console.log(''); - // - // // if (mc.names.indexOf((n as ts.Identifier).text) === -1) { - // // // mc.names.push((n as ts.Identifier).text); - // // // console.log('KIND:', (n as ts.Identifier).text); - // // // console.log((n as ts.Identifier).originalKeywordKind); - // // // console.log(''); - // // } - // break; - // case ts.SyntaxKind.VariableDeclaration: - // // const dec = n as ts.VariableDeclaration; - // // if (dec.name.kind === ts.SyntaxKind.Identifier) { - // // mc.declarations.set((dec.name as ts.Identifier).text, dec.type); - // // } - // break; - // } - // - // firstPassVisitor(n, mc, tc); - // }); - // } - function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> { let mutationContext: MutationContext; const visitor: ts.Visitor = (node: ts.Node): ts.Node => { if (node.kind === ts.SyntaxKind.SourceFile) { - mutationContext = new MutationContext(options, node as ts.SourceFile, program, host); - // firstPassVisitor(node as ts.SourceFile, mutationContext, context); + mutationContext = new MutationContext(options, node as ts.SourceFile, program, host, context); } - // if (node.kind === ts.SyntaxKind.SourceFile) { - // console.log('---------------'); - // console.log('SourceFile'); - // console.log((node as ts.SourceFile).fileName); - // console.log('---------------\n\n'); - // } else { - // console.log(ts.SyntaxKind[node.kind]); - // } - const parent = node.parent; node = onBeforeVisit(node, mutationContext, context); - if (DEBUG) { - const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined'; - console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); - console.log(`Scope: ${scope}`); - console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); - console.log(`File: ${mutationContext.sourceFile.fileName}`); - } + debugText('~~~~~~~~~~~~~~~~~~~~~'); + debugText('Before Mutation:'); + debugText('~~~~~~~~~~~~~~~~~~~~~'); + debugNodeAttributes(node, mutationContext); + debugNodeText(node, mutationContext); for (let mutator of mutators) { node = mutator.mutateNode(node, mutationContext); @@ -264,27 +157,16 @@ export function transform(entryFile: string, options?: Options) { node.parent = parent; util.setParent(node); - if (DEBUG) { - console.log('<============================================'); - if (node.parent) { - if (node.flags === ts.NodeFlags.Synthesized) { - console.log('Cannot get text of synthesized node.'); - } else { - console.log(node.getText()); - } - } else { - console.log('Parent not set, cannot get text.'); - } - console.log('============================================>'); - } - - - if (DEBUG) { - console.log('\n\n'); - } - node = onAfterVisit(node, mutationContext, context); + debugSpaces(); + debugText('~~~~~~~~~~~~~~~~~~~~~'); + debugText('After Mutation:'); + debugText('~~~~~~~~~~~~~~~~~~~~~'); + debugNodeAttributes(node, mutationContext); + debugNodeText(node, mutationContext); + debugSpaces(3); + return ts.visitEachChild(node, visitor, context); }; @@ -299,7 +181,7 @@ export function getOptions(options: Options = {}): Options { return opts; } -function getRootNames(rootNames: string | string[]): string[] { +export function getRootNames(rootNames: string | string[]): string[] { if (Array.isArray(rootNames)) { return rootNames; } @@ -307,11 +189,11 @@ function getRootNames(rootNames: string | string[]): string[] { return [rootNames]; } -function getTempPath(basePath: string, tempFolderName: string): string { +export function getTempPath(basePath: string, tempFolderName: string): string { return path.join(basePath, tempFolderName); } -function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { +export function toTempFilePath(file: string, basePath: string, tempFolderName: string): string { const pathFromBase = path.dirname(file.replace(basePath, '')); const tempPath = getTempPath(basePath, tempFolderName); const fileName = path.basename(file); @@ -319,7 +201,7 @@ function toTempFilePath(file: string, basePath: string, tempFolderName: string): return path.join(tempPath, pathFromBase, fileName); } -function check(diagnostics: ts.Diagnostic[]): boolean { +export function check(diagnostics: ts.Diagnostic[]): boolean { if (diagnostics && diagnostics.length > 0) { notify(bus.events.DIAGNOSTICS, { diagnostics }); console.error(ts.formatDiagnostics(diagnostics, { @@ -333,6 +215,47 @@ function check(diagnostics: ts.Diagnostic[]): boolean { return true; } -function notify(event: string | symbol, ...args: any[]): boolean { +export function notify(event: string | symbol, ...args: any[]): boolean { return bus.emitter.emit(event, args); } + +function debugNodeAttributes(node: ts.Node, mutationContext: MutationContext): void { + if (!DEBUG) return; + const scope = util.getScope(node); + const scopeKind = scope ? ts.SyntaxKind[scope.kind] : 'undefined'; + console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`); + try { + console.log(`Implicit Type: ${mutationContext.getImplicitTypeText(node)}`); + } catch (e) { + console.log('Implicit Type:'); + } + console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`); + console.log(`Scope: ${scopeKind}`); + console.log(`Synthesized: ${node.flags === ts.NodeFlags.Synthesized ? 'Yes' : 'No'}`); + console.log(`File: ${mutationContext.sourceFile.fileName}`); +} + +function debugNodeText(node: ts.Node, mutstionContext: MutationContext) { + if (!DEBUG) return; + console.log('<============================================'); + if (node.parent) { + if (node.flags === ts.NodeFlags.Synthesized) { + console.log('Cannot get text of synthesized node.'); + } else { + console.log(node.getText()); + } + } else { + console.log('Parent not set, cannot get text.'); + } + console.log('============================================>'); +} + +function debugText(text: string) { + if (!DEBUG) return; + console.log(text); +} + +function debugSpaces(spaces: number = 1) { + if (!DEBUG) return; + console.log(Array(Math.abs(spaces) + 1).join('\n')); +} diff --git a/src/util.ts b/src/util.ts index efc1c68..c5cf7e9 100644 --- a/src/util.ts +++ b/src/util.ts @@ -1,5 +1,7 @@ import * as ts from 'typescript'; +export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock; + export function setParent(node: ts.Node): void { if (!node) return; ts.forEachChild(node, n => { From 7eac13189634e5ef3425312f0ad58655ef59b1f0 Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:32:45 +0100 Subject: [PATCH 23/26] Code improvements. --- src/mutators/VariableDeclarationListMutator.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/mutators/VariableDeclarationListMutator.ts b/src/mutators/VariableDeclarationListMutator.ts index 07187b8..c18daab 100644 --- a/src/mutators/VariableDeclarationListMutator.ts +++ b/src/mutators/VariableDeclarationListMutator.ts @@ -102,11 +102,7 @@ export class VariableDeclarationListMutator extends Mutator { private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] { const nodeName = this.context.getTypeDeclarationName(node.name.getText()); - - console.log(node.name.getText()); const implicitType = this.context.getImplicitTypeNode(node.name); - console.log(ts.SyntaxKind[implicitType.kind]); - console.log('\n'); if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) { return [node]; From 371c771297daa6cb326447b627e3231f101ed62b Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:33:02 +0100 Subject: [PATCH 24/26] Changes to examples. --- src/playground/run.ts | 7 +++-- src/playground/snippets/.tsr/source3.ts | 35 --------------------- src/playground/snippets/.tsr/source4.ts | 24 -------------- src/playground/snippets/source3.js | 32 ------------------- src/playground/snippets/source4.js | 21 ------------- src/playground/snippets/source5.js | 32 +++++++++++++++++++ src/playground/snippets/source5.ts | 42 +++++++++++++++++++++++++ src/playground/snippets/source6.js | 3 ++ src/playground/snippets/source6.ts | 3 ++ 9 files changed, 84 insertions(+), 115 deletions(-) delete mode 100644 src/playground/snippets/.tsr/source3.ts delete mode 100644 src/playground/snippets/.tsr/source4.ts delete mode 100644 src/playground/snippets/source3.js delete mode 100644 src/playground/snippets/source4.js create mode 100644 src/playground/snippets/source5.js create mode 100644 src/playground/snippets/source5.ts create mode 100644 src/playground/snippets/source6.js create mode 100644 src/playground/snippets/source6.ts diff --git a/src/playground/run.ts b/src/playground/run.ts index 189bd12..3166a38 100644 --- a/src/playground/run.ts +++ b/src/playground/run.ts @@ -1,6 +1,7 @@ import * as path from 'path'; import * as tsr from '../'; -tsr.transform(path.join(__dirname, './snippets/source4.ts'), { - compilerOptions: {} -}); +const args = process.argv.slice(2); +const file = path.join(__dirname, `./snippets/${args[0]}.ts`); + +tsr.transform(file, { keepTempFiles: true }); diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts deleted file mode 100644 index 9b3372c..0000000 --- a/src/playground/snippets/.tsr/source3.ts +++ /dev/null @@ -1,35 +0,0 @@ -export const bla = t.unknown().assert('bla'); -console.log(bla); -type TestType = { - name: string; -}; -const a: string = t.string().assert('hallo'); -let _bType = t.array(t.number()), b: number[]; -b = _bType.assert([10]); -function testFunction(t: TestType): string { - return 'Hello ' + t.name; -} -console.log(testFunction({ name: 'Alice' })); -let hasAnyType: any; -hasAnyType = 55; -const constAny: any = 10; -function getX() { - return [1, 2, 3]; -} -let _aaaType = t.number(), aaa = _aaaType.assert(10); -const bbb = t.array(t.number()).assert(getX()); -let _xType = t.array(t.number()), x = _xType.assert([5, 10]); -let hasNoType; -hasNoType = 5; -var _hiType = t.string(), hi: string; -hi = _hiType.assert(console); -const y = t.array(t.string()).assert(['hallo', 'du']); -const z = t.unknown().assert('hhh'); -const h = t.array(t.number()).assert([1, 2]); -x = _xType.assert(5); -x = _xType.assert('hi'); -hasNoType = 'str'; -export const bla = t.array(t.number()).assert([10]); -const blub = t.unknown().assert('str'); -let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); -x = _xType.assert(5); diff --git a/src/playground/snippets/.tsr/source4.ts b/src/playground/snippets/.tsr/source4.ts deleted file mode 100644 index e58abd9..0000000 --- a/src/playground/snippets/.tsr/source4.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { bla } from './source3'; -console.log(bla); -type TestType = { - name: string; -}; -const a: string = t.string().assert('hallo'); -let _bType = t.array(t.number()), b: number[]; -b = _bType.assert([10]); -function testFunction(t: TestType): string { - return 'Hello ' + t.name; -} -console.log(testFunction({ name: 'Alice' })); -let hasAnyType: any; -hasAnyType = 55; -const constAny: any = 10; -let _xType = t.array(t.number()), x = _xType.assert([5, 10]); -let hasNoType; -hasNoType = 5; -var _hiType = t.string(), hi: string; -hi = _hiType.assert(console); -const y = t.array(t.string()).assert(['hallo', 'du']); -x = _xType.assert(5); -x = _xType.assert('hi'); -hasNoType = 'str'; diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js deleted file mode 100644 index 9e56a45..0000000 --- a/src/playground/snippets/source3.js +++ /dev/null @@ -1,32 +0,0 @@ -export const bla = t.unknown().assert('bla'); -console.log(bla); -const a = t.string().assert('hallo'); -let _bType = t.array(t.number()), b; -b = _bType.assert([10]); -function testFunction(t) { - return 'Hello ' + t.name; -} -console.log(testFunction({ name: 'Alice' })); -let hasAnyType; -hasAnyType = 55; -const constAny = 10; -function getX() { - return [1, 2, 3]; -} -let _aaaType = t.number(), aaa = _aaaType.assert(10); -const bbb = t.array(t.number()).assert(getX()); -let _xType = t.array(t.number()), x = _xType.assert([5, 10]); -let hasNoType; -hasNoType = 5; -var _hiType = t.string(), hi; -hi = _hiType.assert(console); -const y = t.array(t.string()).assert(['hallo', 'du']); -const z = t.unknown().assert('hhh'); -const h = t.array(t.number()).assert([1, 2]); -x = _xType.assert(5); -x = _xType.assert('hi'); -hasNoType = 'str'; -export const bla = t.array(t.number()).assert([10]); -const blub = t.unknown().assert('str'); -let _wefkhType = t.number(), wefkh = _wefkhType.assert(111); -x = _xType.assert(5); diff --git a/src/playground/snippets/source4.js b/src/playground/snippets/source4.js deleted file mode 100644 index 838722f..0000000 --- a/src/playground/snippets/source4.js +++ /dev/null @@ -1,21 +0,0 @@ -import { bla } from './source3'; -console.log(bla); -const a = t.string().assert('hallo'); -let _bType = t.array(t.number()), b; -b = _bType.assert([10]); -function testFunction(t) { - return 'Hello ' + t.name; -} -console.log(testFunction({ name: 'Alice' })); -let hasAnyType; -hasAnyType = 55; -const constAny = 10; -let _xType = t.array(t.number()), x = _xType.assert([5, 10]); -let hasNoType; -hasNoType = 5; -var _hiType = t.string(), hi; -hi = _hiType.assert(console); -const y = t.array(t.string()).assert(['hallo', 'du']); -x = _xType.assert(5); -x = _xType.assert('hi'); -hasNoType = 'str'; diff --git a/src/playground/snippets/source5.js b/src/playground/snippets/source5.js new file mode 100644 index 0000000..c2e604c --- /dev/null +++ b/src/playground/snippets/source5.js @@ -0,0 +1,32 @@ +import { test } from './source6'; +// Variable with implicit complex type +let _aType = t.array(t.number()), a = _aType.assert(test()); +// Constant with implicit complex type +const b = t.array(t.number()).assert(test()); +// Variable reassignment +a = _aType.assert(19); +// Constant with explicit any type +const c = 10; +// Variable with explicit any type +let d = 'foo'; +d = 'bar'; +// Variable with implicit any type +let f; +f = 'hi'; +// Variable with explicit complex type +let _gType = t.array(t.ref(Symbol)), g; +g = _gType.assert([Symbol(1), Symbol(2)]); +let _hType = t.union(t.void(), t.null()), h; +let _iType = t.union(t.number(), t.array(t.array(t.boolean())), t.ref(Symbol)), i; +let _jType = t.void(), j; +let _kType = t.null(), k; +let _lType = t.ref(Symbol), l; +let _mType = t.this(this), m; +// Variable with implicit complex type +let _eType = t.array(t.union(t.string(), t.number())), e = _eType.assert(['one', 10, 'three']); +e = _eType.assert('hello'); +let _nType = t.number(10), n; +let _oType = t.boolean(true), o; +let _pType = t.string("str"), p; +let _qType = t.boolean(false), q; +let _nType = t.ref(o), n; diff --git a/src/playground/snippets/source5.ts b/src/playground/snippets/source5.ts new file mode 100644 index 0000000..a43b231 --- /dev/null +++ b/src/playground/snippets/source5.ts @@ -0,0 +1,42 @@ +import { test } from './source6'; + +// Variable with implicit complex type +let a = test(); + +// Constant with implicit complex type +const b = test(); + +// Variable reassignment +a = 19; + +// Constant with explicit any type +const c: any = 10; + +// Variable with explicit any type +let d: any = 'foo'; +d = 'bar'; + +// Variable with implicit any type +let f; +f = 'hi'; + +// Variable with explicit complex type +let g: Symbol[]; +g = [Symbol(1), Symbol(2)]; + +let h: void; +let i: number | boolean[][] | Symbol; +let j: undefined; +let k: null; +let l: symbol; +let m: this; + +// Variable with implicit complex type +let e = ['one', 10, 'three']; +e = 'hello'; + +let n: 10; +let o: true; +let p: 'str'; +let q: false; +let n: o; diff --git a/src/playground/snippets/source6.js b/src/playground/snippets/source6.js new file mode 100644 index 0000000..c3ed19e --- /dev/null +++ b/src/playground/snippets/source6.js @@ -0,0 +1,3 @@ +export function test() { + return [5, 10, 2]; +} diff --git a/src/playground/snippets/source6.ts b/src/playground/snippets/source6.ts new file mode 100644 index 0000000..fad06b7 --- /dev/null +++ b/src/playground/snippets/source6.ts @@ -0,0 +1,3 @@ +export function test() { + return [5, 10, 2]; +} From 28044e1039c5ec635cbc67e1befb47e48083d8ea Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:33:24 +0100 Subject: [PATCH 25/26] Moved first pass visitor to archive. --- src/_archived/firstPassVisitor.ts | 85 +++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 src/_archived/firstPassVisitor.ts diff --git a/src/_archived/firstPassVisitor.ts b/src/_archived/firstPassVisitor.ts new file mode 100644 index 0000000..cef9617 --- /dev/null +++ b/src/_archived/firstPassVisitor.ts @@ -0,0 +1,85 @@ +// function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void { +// if (!node) return; +// let checker = program.getTypeChecker(); +// ts.forEachChild(node, n => { +// +// +// // let type = checker.getTypeAtLocation(n); +// // // console.log('TYPE', type); +// // let typeString = checker.typeToString(type); +// // console.log('TYPESTRING', typeString); +// // let source = `let temp: ${typeString};`; +// // console.log('SRC', source); +// // console.log('\n\n\n'); +// // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); +// // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; +// +// switch (n.kind) { +// case ts.SyntaxKind.BinaryExpression: +// // console.log((n as ts.BinaryExpression).getText()); +// // let s = program.getTypeChecker().getSymbolAtLocation(n); +// // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression); +// // console.log(s); +// // console.log(t); +// // console.log('\n\n'); +// break; +// case ts.SyntaxKind.Identifier: +// console.log((n as ts.Identifier).text); +// console.log('-----------------------'); +// +// +// +// // let t = checker.getTypeAtLocation(n); +// // // console.log(checker.getPropertiesOfType(t)); +// // // t = checker.getWidenedType(t); +// // // +// // console.log(ts.TypeFlags[t.flags]); +// +// let type = checker.getTypeAtLocation(n); +// +// let typeString = checker.typeToString(type); +// console.log(typeString); +// let source = `let temp: ${typeString};`; +// +// let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015); +// let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type; +// +// // +// // let asm = type.aliasSymbol; +// // +// // if (asm) { +// // if (asm.declarations && asm.declarations[0]) { +// // console.log(asm.declarations.length); +// // let asmi = asm.declarations[0] as ts.VariableDeclaration; +// // if (asmi.type) { +// // console.log('has type'); +// // console.log(ts.SyntaxKind[asmi.type.kind]); +// // } +// // } +// // } +// // +// console.log(ts.TypeFlags[type.flags]); +// console.log('\n\n'); +// +// // console.log('KIND:', (n as ts.Identifier).text); +// // console.log((n as ts.Identifier).originalKeywordKind); +// // console.log(''); +// +// // if (mc.names.indexOf((n as ts.Identifier).text) === -1) { +// // // mc.names.push((n as ts.Identifier).text); +// // // console.log('KIND:', (n as ts.Identifier).text); +// // // console.log((n as ts.Identifier).originalKeywordKind); +// // // console.log(''); +// // } +// break; +// case ts.SyntaxKind.VariableDeclaration: +// // const dec = n as ts.VariableDeclaration; +// // if (dec.name.kind === ts.SyntaxKind.Identifier) { +// // mc.declarations.set((dec.name as ts.Identifier).text, dec.type); +// // } +// break; +// } +// +// firstPassVisitor(n, mc, tc); +// }); +// } From ebc9d7d7d0ccca28941fbed2c0eb4897421f8c6c Mon Sep 17 00:00:00 2001 From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com> Date: Thu, 23 Mar 2017 16:33:57 +0100 Subject: [PATCH 26/26] Changes to tsconfig excludes. --- tsconfig.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tsconfig.json b/tsconfig.json index d5ebef7..8dd2d2e 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -21,8 +21,8 @@ ], "exclude": [ "node_modules", + "src/playground/snippets", "dist", - "src/compiler/_archive", - "src/playground" + "src/compiler/_archive" ] }