swc/crates/swc_ecma_parser/tests/tsc/parserSyntaxWalker.generated.ts

//declare module "fs" {
//    export class File {
//        constructor(filename: string);
//        public ReadAllText(): string;
//    }
//    export interface IFile {
//        [index: number]: string;
//    }
//}

//import fs = module("fs");


//module TypeScriptAllInOne {
//    export class Program {
//        static Main(...args: string[]) {
//            try {
//                var bfs = new BasicFeatures();
//                var retValue: number = 0;

//                retValue = bfs.VARIABLES();
//                if (retValue != 0) {

//                    return 1;
//                }

//                retValue = bfs.STATEMENTS(4);
//                if (retValue != 0) {

//                    return 1;
//                }


//                retValue = bfs.TYPES();
//                if (retValue != 0) {

//                    return 1;
//                }

//                retValue = bfs.OPERATOR();
//                if (retValue != 0) {

//                    return 1;
//                }
//            }
//            catch (e) {
//                console.log(e);
//            }
//            finally {

//            }

//            console.log('Done');

//            return 0;

//        }
//    }

//    class BasicFeatures {
//        /// <summary>
//        /// Test various of variables. Including nullable,key world as variable,special format
//        /// </summary>
//        /// <returns></returns>
//        public VARIABLES(): number {
//            var local = Number.MAX_VALUE;
//            var min = Number.MIN_VALUE;
//            var inf = Number.NEGATIVE_INFINITY;
//            var nan = Number.NaN;
//            var undef = undefined;

//            var п = local;
//            var м = local;

//            var local5 = <fs.File>null;
//            var local6 = local5 instanceof fs.File;

//            var hex = 0xBADC0DE, Hex = 0XDEADBEEF;
//            var float = 6.02e23, float2 = 6.02E-23
//            var char = 'c', \u0066 = '\u0066', hexchar = '\x42';
//            var quoted = '"', quoted2 = "'";
//            var reg = /\w*/;
//            var objLit = { "var": number = 42, equals: function (x) { return x["var"] === 42; }, toString: () => 'objLit{42}' };
//            var weekday = Weekdays.Monday;

//            var con = char + f + hexchar + float.toString() + float2.toString() + reg.toString() + objLit + weekday;

//            //
//            var any = 0;
//            var boolean = 0;
//            var declare = 0;
//            var constructor = 0;
//            var get = 0;
//            var implements = 0;
//            var interface = 0;
//            var let = 0;
//            var module = 0;
//            var number = 0;
//            var package = 0;
//            var private = 0;
//            var protected = 0;
//            var public = 0;
//            var set = 0;
//            var static = 0;
//            var string = 0;
//            var yield = 0;

//            var sum3 = any + boolean + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set + static + string + yield;

//            return 0;
//        }

//        /// <summary>
//        /// Test different statements. Including if-else,swith,foreach,(un)checked,lock,using,try-catch-finally
//        /// </summary>
//        /// <param name="i"></param>
//        /// <returns></returns>
//        STATEMENTS(i: number): number {
//            var retVal = 0;
//            if (i == 1)
//                retVal = 1;
//            else
//                retVal = 0;
//            switch (i) {
//                case 2:
//                    retVal = 1;
//                    break;
//                case 3:
//                    retVal = 1;
//                    break;
//                default:
//                    break;
//            }

//            for (var x in { x: 0, y: 1 }) {
//            }

//            try {
//                throw null;
//            }
//            catch (Exception) {
//            }
//            finally {
//                try { }
//                catch (Exception) { }
//            }

//            return retVal;
//        }

//        /// <summary>
//        /// Test types in ts language. Including class,struct,interface,delegate,anonymous type
//        /// </summary>
//        /// <returns></returns>
//        public TYPES(): number {
//            var retVal = 0;
//            var c = new CLASS();
//            var xx: IF = c;
//            retVal += c.Property;
//            retVal += c.Member();
//            retVal += xx ^= Foo() ? 0 : 1;

//            //anonymous type
//            var anony = { a: new CLASS() };

//            retVal += anony.a.d();

//            return retVal;
//        }


//        ///// <summary>
//        ///// Test different operators
//        ///// </summary>
//        ///// <returns></returns>
//        public OPERATOR(): number {
//            var a: number[] = [1, 2, 3, 4,  implements , ];/*[] bug*/ // YES []
//            var i = a[1];/*[]*/
//            i = i + i - i * i / i % i & i | i ^ i;/*+ - * / % & | ^*/
//            var b = true && false || true ^ false;/*& | ^*/
//            b = !b;/*!*/
//            i = ~i;/*~i*/
//            b = i < (i -  continue ) && (i + 1) > i;/*< && >*/
//            var f = true ? 1 : 0;/*? :*/   // YES :
//            i++;/*++*/
//            i--;/*--*/
//            b = true && false || true;/*&& ||*/
//            i = i << 5;/*<<*/
//            i = i >> 5;/*>>*/
//            var j = i;
//            b = i == j && i != j && i <= j && i >= j;/*= == && != <= >=*/
//            i += <number>5.0;/*+=*/
//            i -= i;/*-=*/
//            i *= i;/**=*/
//            if (i == 0)
//                i++;
//            i /= i;/*/=*/
//            i %= i;/*%=*/
//            i &= i;/*&=*/
//            i |= i;/*|=*/
//            i ^= i;/*^=*/
//            i <<= i;/*<<=*/
//            i >>= i;/*>>=*/

//            if (i == 0 && !b && f == 1)
//                return 0;
//            else return 1;
//        }

//    }

//    interface IF {
//        Foo <!-- ): boolean;
//    }

//    class CLASS implements IF {

//        public d = () =>  '  return 0; };
//        public get Property() { return 0; }
//        public Member() {
//            return 0;
//        }
//        public Foo(): boolean {
//            var myEvent = () => { return 1; };
//            if (myEvent() == 1)
//                return true;
//            else
//                return false;
//        }
//    }


//    // todo: use these
//    class A {
//        public method1(val:number) {
//            return val;
//        }
//        public method2() {
//            return 2 * this.method1(2);
//        }
//    }

//    class B extends A {

//        public method2() {
//            return this.method1(2);
//        }
//    }

//    class Overloading {

//        private otherValue = 42;

//        constructor(private value: number, public name: string) { }
       
//        public Overloads(value: string);
//        public Overloads(value: string, ...rest: string[]) { }

//        public DefaultValue(value?: string = "Hello") { }
//    }
//}

//enum Weekdays {
//    Monday,
//    Tuesday,
//    Weekend,
//}

//enum Fruit {
//    Apple,
//    Pear
//}

//interface IDisposable {
//    Dispose(): void;
//}

//TypeScriptAllInOne.Program.Main();