Make export default class the main file class in GDScript, add support for subclasses

.prettierignore

@@ -1 +0,0 @@
-

README.md

@@ -41,6 +41,132 @@ To compile all source files once:
 
 ## Details and Differences
 
+### Classes
+
+A single exported class in a file is always treated as the main GDScript class.
+
+```ts
+export class MyNode extends Node2D {
+  constructor() {
+    super()
+    print("Hello world")
+  }
+}
+```
+
+```gdscript
+extends Node2D
+class_name MyNode
+
+func _ready():
+  print("Hello world")
+```
+
+Classes marked `default` are the main class (the class that gets attached to the node when you add a script to a node in Godot). Other classes are inner classes in Godot. There is one exception to this rule: if you have only a single class in a file, that automatically becomes the main class, default or not.
+
+```ts
+export default class MyNode extends Node2D {
+  constructor() {
+    super()
+    print("Hello main class")
+  }
+}
+
+export class ExportedInnerClass {
+  constructor() {
+    print("Hello ExportedInnerClass")
+  }
+}
+
+class NotExportedInnerClass {
+  constructor() {
+    print("Hello NotExportedInnerClass")
+  }
+}
+```
+
+```gdscript
+extends Node2D
+class_name MyNode
+
+class ExportedInnerClass
+  func _init():
+    print("Hello ExportedInnerClass")
+
+class NotExportedInnerClass
+  func _init():
+    print("Hello NotExportedInnerClass")
+
+func _ready():
+  print("Hello main class")
+```
+
+If you prefer not to use `default`, you can also decorate the class with `@main`, which has the same effect. Again, this is only necessary if you are using multiple classes in a file.
+
+```ts
+@main
+export class MainClass extends Node2D {
+  constructor() {
+    super()
+    print("Hello MainClass")
+  }
+}
+
+export class OtherClass {
+  constructor() {
+    print("Hello OtherClass")
+  }
+}
+```
+
+```gdscript
+extends Node2D
+class_name MainClass
+
+class OtherClass
+  func _init():
+    print("Hello OtherClass")
+
+func _ready():
+  print("Hello MainClass")
+```
+
+If you want single class in a file to be an inner class in Godot then you need to explicitly mark it with `@inner` attribute.
+
+```ts
+@inner
+export class MyNode extends Node2D {
+  constructor() {
+    super()
+    print("Hello world")
+  }
+}
+```
+
+```gdscript
+class MyNode extends Node2D:
+  func _init().():
+    print("Hello world")
+```
+
+If a class is marked `default`, it can be anonymous. This omits `class_name` generation.
+
+```ts
+export default class extends Node2D {
+  constructor() {
+    super()
+    print("Hello world")
+  }
+}
+```
+
+```gdscript
+extends Node2D
+
+func _ready():
+  print("Hello world")
+```
+
 ### `get_node`
 
 `get_node` has been supercharged - it will now autocomplete the names of all
@@ -53,7 +179,7 @@ get type errors if you break any `get_node` calls!!
 
 ts2gd also provides a way to get any node by name, even the ones it can't verify exist:
 
-```
+```ts
 this.get_node<Label>("MyLabel")
 ```
 
@@ -73,13 +199,13 @@ Godot decides to put a bunch of enum values into global scope. I think this clut
 
 For instance,
 
-```
+```gdscript
 Input.is_key_pressed(KEY_W)
 ```
 
 becomes
 
-```
+```ts
 Input.is_key_pressed(KeyList.KEY_SPACE)
 ```
 
@@ -93,13 +219,13 @@ The RPC syntax has been improved.
 
 GDScript:
 
-```
+```gdscript
 this.rpc("my_rpc_method", "some-argument)
 ```
 
 TypeScript:
 
-```
+```ts
 this.my_rpc_method.rpc("some-argument")
 ```
 
@@ -111,7 +237,7 @@ Signals have been improved. All signals now start with `$` and are properties of
 
 This is what connect looks like in ts2gd:
 
-```
+```ts
 this.my_button.$pressed.connect(() => {
   print("Clicked the button!)
 })
@@ -129,7 +255,7 @@ yield this.get_tree().$idle_frame
 
 This is what emit looks like in ts2gd:
 
-```
+```ts
 class MySignallingClass extends Node2D {
   $my_signal!: Signal // ! to avoid the TS error about this signal being unassigned
 
@@ -145,9 +271,10 @@ In order to make a class autoload, decorate your class with `@autoload`, and cre
 
 Here's a full example of an autoload class.
 
-```
+```ts
+// autoload can be specified only on a main class (marked 'export default' or with '@main' decorator)
 @autoload
-class MyAutoloadClass extends Node2D {
+export default class MyAutoloadClass extends Node2D {
   public hello = "hi"
 }
 
@@ -158,8 +285,8 @@ export const MyAutoload = new MyAutoloadClass()
 
 In order to mark an instance variable as `export`, use `@exports`, e.g.:
 
-```
-class ExportExample extends Node2D {
+```ts
+export default class ExportExample extends Node2D {
   @exports
   public hello = "exported"
 }
@@ -169,9 +296,9 @@ class ExportExample extends Node2D {
 
 In order to mark a script as `tool`, use `@tool`.
 
-```
+```ts
 @tool
-class MyToolScript extends Node2D {
+export default class MyToolScript extends Node2D {
   // ... do some tool script work here
 }
 ```
@@ -184,7 +311,7 @@ To mark a method as remotesync or remote, use `@remotesync` and `@remote`, respe
 
 TypeScript sadly has no support for operator overloading.
 
-```
+```ts
 const v1 = Vector(1, 2)
 const v2 = Vector(1, 2);
 
@@ -194,13 +321,13 @@ v1.mul(v2); // v1 * v2
 v1.div(v2); // v1 / v2
 ```
 
-The add/sub/mul/div gets compiled into the corresponding arithmatic.
+The add/sub/mul/div gets compiled into the corresponding arithmetic.
 
 ### Dictionary
 
 The default TS dictionary (e.g. `const dict = { a: 1 }`) only supports string, number and symbol as keys. If you want anything else, you can just use the Dictionary type, and use `.put` instead of square bracket access.
 
-```
+```ts
 const myComplexDict: Dictionary<Node2D, int> = todict({})
 
 myComplexDict.put(myNode, 5)
@@ -210,7 +337,7 @@ myComplexDict.put(myNode, 5)
 
 If you'd like ts2gd to generate the latest TS definitions from Godot, clone the Godot repository and point it at the 3.x tag. Then add the following to your ts2gd.json:
 
-```
+```json
   "godotSourceRepoPath": "/path/to/your/godot/clone"
 ```
 
@@ -274,7 +401,7 @@ Need something more customized? You can provide an array of [anymatch](https://w
 - [x] strongly type input action names
 - [x] handle renames better - delete the old compiled file, etc.
 - [ ] refactoring class names doesn't really work right now because i think we need to rename types in tscn files...
-- [ ] would be nice to declare multiple classes in the same .ts file and have the compiler sort it out
+- [x] would be nice to declare multiple classes in the same .ts file and have the compiler sort it out
 - [x] add a way to install ts2gd as a global command
 - [x] ensure that signal arguments match up
 - [ ] add a way to use ts2gd via installer rather than command line

_godot_defs/static/@base.d.ts

@@ -108,6 +108,8 @@ declare function exports(target: Node, name: string): void;
 declare const export_flags: (...flags: any[]) => (target: Node, name: string) => void
 declare function autoload(target: typeof Node): void
 declare function tool(target: typeof Node): void;
+declare function main(target: typeof Node): void;
+declare function inner(target: typeof Node): void;
 
 declare type int = number;
 declare type float = number;

generate_library_defs/generate_base.ts

@@ -117,6 +117,8 @@ declare function exports(target: Node, name: string): void;
 declare const export_flags: (...flags: any[]) => (target: Node, name: string) => void
 declare function autoload(target: typeof Node): void
 declare function tool(target: typeof Node): void;
+declare function main(target: typeof Node): void;
+declare function inner(target: typeof Node): void;
 
 declare type int = number;
 declare type float = number;

package.json

@@ -33,8 +33,10 @@
     "semi": false
   },
   "lint-staged": {
+    "*.ts": [
+      "eslint --fix"
+    ],
     "*.{ts,json}": [
-      "eslint --fix",
       "prettier --write"
     ]
   },

parse_node.ts

@@ -76,6 +76,7 @@ export type ParseState = {
    * Is the current file we're in an autoload class?
    */
   isAutoload: boolean
+  isMainClass: boolean
   mostRecentControlStructureIsSwitch: boolean
   mostRecentForStatement?: {
     incrementor: string

parse_node/parse_call_expression.ts

@@ -449,7 +449,7 @@ func b():
 export const testArrowFunction: Test = {
   ts: `
 const test = () => 5;
-test()  
+test()
   `,
   expected: `
 func __gen(captures):
@@ -616,7 +616,7 @@ export class Test {
   foo() {
     let enem: any;
 
-    enem.$on_die.connect(() => { this.enemies.erase(enem) });  
+    enem.$on_die.connect(() => { this.enemies.erase(enem) });
   }
 }
   `,
@@ -628,7 +628,7 @@ func __gen(captures):
 var enemies
 func foo():
   var enem
-  enem.connect("on_die", self, "__gen", [{"enem": enem}])  
+  enem.connect("on_die", self, "__gen", [{"enem": enem}])
 `,
 }