Making syscall/js CSP compatible (#1168)

matthewbelisle-wf · web-flow · commit dd702cc197f8 · 2022-10-25T19:15:36.000+01:00
Replaces use of dynamically evaluated code with helpers in prelude.
diff --git a/compiler/natives/src/syscall/js/js.go b/compiler/natives/src/syscall/js/js.go
@@ -22,27 +22,23 @@ const (
 	TypeFunction
 )
 
+// Same order as Type constants
+var typeNames = []string{
+	"undefined",
+	"null",
+	"boolean",
+	"number",
+	"string",
+	"symbol",
+	"object",
+	"function",
+}
+
 func (t Type) String() string {
-	switch t {
-	case TypeUndefined:
-		return "undefined"
-	case TypeNull:
-		return "null"
-	case TypeBoolean:
-		return "boolean"
-	case TypeNumber:
-		return "number"
-	case TypeString:
-		return "string"
-	case TypeSymbol:
-		return "symbol"
-	case TypeObject:
-		return "object"
-	case TypeFunction:
-		return "function"
-	default:
+	if int(t) < 0 || len(typeNames) <= int(t) {
 		panic("bad type")
 	}
+	return typeNames[t]
 }
 
 func (t Type) isObject() bool {
@@ -110,40 +106,30 @@ func objectToValue(obj *js.Object) Value {
 }
 
 var (
-	id           *js.Object
-	instanceOf   *js.Object
-	getValueType *js.Object
+	id         *js.Object
+	instanceOf *js.Object
+	typeOf     *js.Object
 )
 
 func init() {
 	if js.Global != nil {
-		id = js.Global.Call("Function", "x", "return x")
-		instanceOf = js.Global.Call("Function", "x", "y", "return x instanceof y")
-		getValueType = js.Global.Call("Function", "x", `
-  if (typeof(x) === "undefined") {
-    return 0; // TypeUndefined
-  }
-  if (x === null) {
-    return 1; // TypeNull
-  }
-  if (typeof(x) === "boolean") {
-    return 2; // TypeBoolean
-  }
-  if (typeof(x) === "number") {
-    return 3; // TypeNumber
-  }
-  if (typeof(x) === "string") {
-    return 4; // TypeString
-  }
-  if (typeof(x) === "symbol") {
-    return 5; // TypeSymbol
-  }
-  if (typeof(x) === "function") {
-    return 7; // TypeFunction
-  }
-  return 6; // TypeObject
-`)
+		id = js.Global.Get("$id")
+		instanceOf = js.Global.Get("$instanceOf")
+		typeOf = js.Global.Get("$typeOf")
+	}
+}
+
+func getValueType(obj *js.Object) Type {
+	if obj == nil {
+		return TypeNull
+	}
+	name := typeOf.Invoke(obj).String()
+	for type2, name2 := range typeNames {
+		if name == name2 {
+			return Type(type2)
+		}
 	}
+	return TypeObject
 }
 
 func ValueOf(x interface{}) Value {
@@ -322,7 +308,7 @@ func (v Value) Truthy() bool {
 }
 
 func (v Value) Type() Type {
-	return Type(getValueType.Invoke(v.internal()).Int())
+	return Type(getValueType(v.internal()))
 }
 
 func (v Value) IsNull() bool {
diff --git a/compiler/prelude/prelude.go b/compiler/prelude/prelude.go
@@ -564,4 +564,16 @@ var $unsafeMethodToFunction = function(typ, name, isPtr) {
      }
   }
 };
+
+var $id = function(x) {
+  return x;
+};
+
+var $instanceOf = function(x, y) {
+  return x instanceof y;
+};
+
+var $typeOf = function(x) {
+  return typeof(x);
+};
 `
diff --git a/compiler/prelude/prelude_min.go b/compiler/prelude/prelude_min.go

Original file line number	Diff line number	Diff line change
`@@ -564,4 +564,16 @@ var $unsafeMethodToFunction = function(typ, name, isPtr) {`
`564`	`564`	`}`
`565`	`565`	`}`
`566`	`566`	`};`
	`567`	`+`
	`568`	`+var $id = function(x) {`
	`569`	`+ return x;`
	`570`	`+};`
	`571`	`+`
	`572`	`+var $instanceOf = function(x, y) {`
	`573`	`+ return x instanceof y;`
	`574`	`+};`
	`575`	`+`
	`576`	`+var $typeOf = function(x) {`
	`577`	`+ return typeof(x);`
	`578`	`+};`
`567`	`579`	`