Merge branch 'types' into main

wasm/wasm.go

@@ -13,32 +13,22 @@ type JsResolver struct {
 	jsResolver js.Value
 }
 
-func (r *JsResolver) Resolve(name string) (core.Node, error) {
+func (r *JsResolver) IsSame(a, b string) bool {
+	return a == b
+}
+
+func (r *JsResolver) Resolve(name string) (string, error) {
 	jsv := r.jsResolver.Invoke(name)
 
 	if jsv.Type() == js.TypeUndefined {
-		return nil, errors.New("cannot find import with name " + name)
+		return "", errors.New("cannot find import with name " + name)
 	}
 
 	if jsv.Type() != js.TypeString {
-		return nil, errors.New("invalid value for source: " + jsv.String())
+		return "", errors.New("invalid value for source: " + jsv.String())
 	}
 
-	source := jsv.String()
-
-	l := core.NewLexer(source)
-	tokens, err := l.Tokenize()
-	if err != nil {
-		return nil, err
-	}
-
-	p := core.NewParser(tokens)
-	tree, err := p.Parse()
-	if err != nil {
-		return nil, err
-	}
-
-	return tree, nil
+	return jsv.String(), nil
 }
 
 func jsError(err error) interface{} {
@@ -55,7 +45,8 @@ func jsErrorOfString(err string) interface{} {
 func run(_ js.Value, args []js.Value) interface{} {
 	source := args[0].String()
 	outputHandler := args[1]
-	resolver := args[2]
+	errorHandler := args[2]
+	resolver := args[3]
 	log.Printf("got source: %s", source)
 
 	lexer := core.NewLexer(source)
@@ -67,17 +58,25 @@ func run(_ js.Value, args []js.Value) interface{} {
 
 	log.Printf("got tokens: %v", tokens)
 
-	parser := core.NewParser(tokens)
+	parser := core.NewParser(source, tokens)
 
-	tree, err := parser.Parse()
+	tree, err := parser.Parse(source)
 
 	if err != nil {
-		return jsErrorOfString(err.Error())
+		var e core.FormatedError
+		if errors.As(err, &e) {
+			errorHandler.Invoke(e.Format())
+			return nil
+		}
+		errorHandler.Invoke(err.Error())
+		return nil
 	}
 
 	log.Printf("Parsed tree: %s", tree.String())
 
-	compiler := core.NewCompiler()
+	compiler := core.NewCompiler([]rune(source))
+
+	log.Println("Set imports resolver")
 
 	compiler.SetImportsResolver(&JsResolver{
 		resolver,
@@ -91,6 +90,13 @@ func run(_ js.Value, args []js.Value) interface{} {
 
 	err = compiler.Compile(tree)
 	if err != nil {
+		var e core.CompilerError
+		if errors.As(err, &e) {
+			errorHandler.Invoke(e.Format())
+			return nil
+		}
+
+		errorHandler.Invoke(err.Error())
 		return nil
 	}
 
@@ -100,20 +106,28 @@ func run(_ js.Value, args []js.Value) interface{} {
 
 	// overwrite output
 	vm.SetGlobal("write", &core.BuiltinFunctionValue{
-		Name:       "write",
-		Parameters: []string{"value"},
-		F: func(vm *core.VM, this core.Value, v map[string]core.Value) (core.Value, error) {
-			log.Printf("Writing value: %s", v["value"].String())
-			outputHandler.Invoke(js.ValueOf(v["value"].String() + "\n"))
+		Name: "write",
+		Signature: &core.FunctionSignature{
+			In:  []core.TypeSignature{&core.StringSignature{}},
+			Out: &core.NilSignature{},
+		},
+		F: func(vm *core.VM, this core.Value, args []core.Value) (core.Value, error) {
+			s := args[0].String()
+			log.Printf("Writing value: %s", s)
+			outputHandler.Invoke(js.ValueOf(s + "\n"))
 			return nil, nil
 		},
 	})
 	vm.SetGlobal("print", &core.BuiltinFunctionValue{
-		Name:       "print",
-		Parameters: []string{"value"},
-		F: func(vm *core.VM, this core.Value, v map[string]core.Value) (core.Value, error) {
-			log.Printf("Printing value: %s", v["value"].String())
-			outputHandler.Invoke(js.ValueOf(v["value"].String()))
+		Name: "print",
+		Signature: &core.FunctionSignature{
+			In:  []core.TypeSignature{&core.StringSignature{}},
+			Out: &core.NilSignature{},
+		},
+		F: func(vm *core.VM, this core.Value, args []core.Value) (core.Value, error) {
+			s := args[0].String()
+			log.Printf("Printing value: %s", s)
+			outputHandler.Invoke(js.ValueOf(s))
 			return nil, nil
 		},
 	})