support string interpolation for object pattern key

cli/test.yaml

@@ -2532,31 +2532,35 @@
 
 - name: binding an object deeply
   args:
-    - '. as {$foo, bar: {baz: {$qux}}} | {$foo, $qux}'
-  input: '{} {"foo": 10} {"foo": 20, "bar": { "baz": { "qux": 30 } } }'
+    - '. as {$foo, bar: {"baz": {$qux}, "": $quy}} | {$foo, $qux, $quy}'
+  input: '{} {"foo": 10} {"foo": 20, "bar": { "baz": { "qux": 30 }, "": -1 } }'
   expected: |
     {
       "foo": null,
-      "qux": null
+      "qux": null,
+      "quy": null
     }
     {
       "foo": 10,
-      "qux": null
+      "qux": null,
+      "quy": null
     }
     {
       "foo": 20,
-      "qux": 30
+      "qux": 30,
+      "quy": -1
     }
 
 - name: binding an object with expression
   args:
-    - '. as {as: $foo, ("e"+"x"+"p"): $bar, (.foo): $baz} | [$foo, $bar, $baz]'
-  input: '{"as": 1, "exp": 2, "foo": "bar", "bar": 3}'
+    - '. as {as: $foo, ("e"+"x"+"p"): $bar, (.foo): $baz, "\(.qux)": $qux} | [$foo, $bar, $baz, $qux]'
+  input: '{"as": 1, "exp": 2, "foo": "bar", "bar": 3, "qux": "quux", "quux": 4}'
   expected: |
     [
       1,
       2,
-      3
+      3,
+      4
     ]
 
 - name: binding an object error

compiler.go

@@ -576,9 +576,11 @@ func (c *compiler) compilePattern(p *Pattern) ([][2]int, error) {
 					key, name = key[1:], key
 				}
 				c.append(&code{op: oppush, v: key})
-			} else if kv.KeyString != "" {
-				key = kv.KeyString[1 : len(kv.KeyString)-1]
-				c.append(&code{op: oppush, v: key})
+			} else if kv.KeyString != nil {
+				c.append(&code{op: opload, v: v})
+				if err := c.compileString(kv.KeyString, nil); err != nil {
+					return nil, err
+				}
 			} else if kv.Query != nil {
 				c.append(&code{op: opload, v: v})
 				if err := c.compileQuery(kv.Query); err != nil {

parser.go.y

@@ -282,9 +282,9 @@ objectpattern
     {
         $$ = &PatternObject{Key: $1, Val: $3.(*Pattern)}
     }
-    | tokString ':' pattern
+    | string ':' pattern
     {
-        $$ = &PatternObject{KeyString: $1, Val: $3.(*Pattern)}
+        $$ = &PatternObject{KeyString: $1.(*String), Val: $3.(*Pattern)}
     }
     | '(' query ')' ':' pattern
     {

query.go

@@ -352,7 +352,7 @@ func (e *Pattern) String() string {
 // PatternObject ...
 type PatternObject struct {
 	Key       string
-	KeyString string
+	KeyString *String
 	Query     *Query
 	Val       *Pattern
 	KeyOnly   string
@@ -362,8 +362,8 @@ func (e *PatternObject) String() string {
 	var s strings.Builder
 	if e.Key != "" {
 		s.WriteString(e.Key)
-	} else if e.KeyString != "" {
-		s.WriteString(e.KeyString)
+	} else if e.KeyString != nil {
+		fmt.Fprint(&s, e.KeyString)
 	} else if e.Query != nil {
 		fmt.Fprintf(&s, "(%s)", e.Query)
 	}