Fix #589: support non-scalar YAML mapping keys in YAMLParser

When SnakeYAML emits SequenceStart or MappingStart for an explicit complex
key (? [...] or ? {...}), consume the key structure and expose it as a
flow-style string property name so YAMLMapper/readTree can parse the document.

Author: arimu1

yaml/src/main/java/tools/jackson/dataformat/yaml/YAMLParser.java

@@ -356,6 +356,15 @@ public JsonToken nextToken() throws JacksonException
                             _streamReadContext = _streamReadContext.getParent();
                             return _updateToken(JsonToken.END_OBJECT);
                         }
+                        // [dataformats-text#589]: complex (non-scalar) mapping keys
+                        if (evt.getEventId() == Event.ID.SequenceStart
+                                || evt.getEventId() == Event.ID.MappingStart) {
+                            final String name = _decodeComplexPropertyName(evt);
+                            _streamReadConstraints.validateNameLength(name.length());
+                            _currentName = name;
+                            _streamReadContext.setCurrentName(name);
+                            return _updateToken(JsonToken.PROPERTY_NAME);
+                        }
                         _reportError("Expected a property name (Scalar value in YAML), got this instead: "+evt);
                     }
 
@@ -481,6 +490,119 @@ protected Event nextEvent() {
         return _yamlParser.next();
     }
 
+    /**
+     * Helper method called when a non-scalar event (Sequence or Mapping start) is encountered
+     * where a property name is expected -- indicates a "complex key" in YAML terms.
+     * Consumes the full key structure and converts to a canonical String representation
+     * (flow-style) so that Jackson's scalar-only property name model can represent it.
+     *
+     * @since 3.2
+     */
+    protected String _decodeComplexPropertyName(Event evt) throws JacksonException
+    {
+        StringBuilder sb = new StringBuilder(32);
+        _appendComplexKey(evt, sb, 0);
+        return sb.toString();
+    }
+
+    private void _appendComplexKey(Event evt, StringBuilder sb, int depth) throws JacksonException
+    {
+        _streamReadConstraints.validateNestingDepth(depth);
+        switch (evt.getEventId()) {
+        case Scalar:
+            _appendComplexKeyScalar(((ScalarEvent) evt).getValue(), sb);
+            return;
+        case SequenceStart:
+            sb.append('[');
+            _appendComplexKeySequenceContent(sb, depth + 1);
+            sb.append(']');
+            return;
+        case MappingStart:
+            sb.append('{');
+            _appendComplexKeyMappingContent(sb, depth + 1);
+            sb.append('}');
+            return;
+        default:
+            _reportError("Unexpected YAML event for complex property name, expected Scalar, Sequence or Mapping start, got: "+evt);
+        }
+    }
+
+    private void _appendComplexKeySequenceContent(StringBuilder sb, int depth) throws JacksonException
+    {
+        boolean first = true;
+        while (true) {
+            Event evt = nextEvent();
+            if (evt == null) {
+                _reportError("Unexpected end-of-input in complex property name (sequence)");
+            }
+            if (evt.getEventId() == Event.ID.SequenceEnd) {
+                return;
+            }
+            if (!first) {
+                sb.append(", ");
+            }
+            first = false;
+            _appendComplexKey(evt, sb, depth);
+        }
+    }
+
+    private void _appendComplexKeyMappingContent(StringBuilder sb, int depth) throws JacksonException
+    {
+        boolean first = true;
+        while (true) {
+            Event keyEvt = nextEvent();
+            if (keyEvt == null) {
+                _reportError("Unexpected end-of-input in complex property name (mapping)");
+            }
+            if (keyEvt.getEventId() == Event.ID.MappingEnd) {
+                return;
+            }
+            if (!first) {
+                sb.append(", ");
+            }
+            first = false;
+            _appendComplexKey(keyEvt, sb, depth);
+            sb.append(": ");
+            Event valEvt = nextEvent();
+            if (valEvt == null) {
+                _reportError("Unexpected end-of-input in complex property name (mapping value)");
+            }
+            _appendComplexKey(valEvt, sb, depth);
+        }
+    }
+
+    private void _appendComplexKeyScalar(String value, StringBuilder sb)
+    {
+        if (_needsQuotesForComplexKey(value)) {
+            sb.append('"');
+            for (int i = 0, len = value.length(); i < len; ++i) {
+                char c = value.charAt(i);
+                if (c == '"' || c == '\\') {
+                    sb.append('\\');
+                }
+                sb.append(c);
+            }
+            sb.append('"');
+        } else {
+            sb.append(value);
+        }
+    }
+
+    private boolean _needsQuotesForComplexKey(String value)
+    {
+        if (value.isEmpty()) {
+            return true;
+        }
+        for (int i = 0, len = value.length(); i < len; ++i) {
+            char c = value.charAt(i);
+            if (c == ':' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}'
+                    || c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+                return true;
+            }
+        }
+        return false;
+    }
+
     protected JsonToken _decodeScalar(ScalarEvent scalar) throws JacksonException
     {
         String value = scalar.getValue();

yaml/src/test/java/tools/jackson/dataformat/yaml/deser/StreamingYAMLParseTest.java

@@ -10,6 +10,7 @@
 
 import tools.jackson.core.JsonParser;
 import tools.jackson.core.JsonToken;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.dataformat.yaml.JacksonYAMLParseException;
 import tools.jackson.dataformat.yaml.ModuleTestBase;
 import tools.jackson.dataformat.yaml.YAMLFactory;
@@ -663,6 +664,51 @@ public void testYamlParseFailsWhenCodePointLimitVerySmall() throws Exception
         }
     }
 
+    // [dataformats-text#589]: sequence (and mapping) as mapping key
+    @Test
+    public void testComplexMappingKeySequence() throws Exception
+    {
+        final String YAML = "? [user, 123]\n: name: Ivan\n  age: 30\n";
+        try (JsonParser p = MAPPER.createParser(YAML)) {
+            assertToken(JsonToken.START_OBJECT, p.nextToken());
+            assertToken(JsonToken.PROPERTY_NAME, p.nextToken());
+            assertEquals("[user, 123]", p.currentName());
+            assertEquals("[user, 123]", p.getString());
+            assertToken(JsonToken.START_OBJECT, p.nextToken());
+            assertToken(JsonToken.PROPERTY_NAME, p.nextToken());
+            assertEquals("name", p.currentName());
+            assertToken(JsonToken.VALUE_STRING, p.nextToken());
+            assertEquals("Ivan", p.getString());
+            assertToken(JsonToken.PROPERTY_NAME, p.nextToken());
+            assertEquals("age", p.currentName());
+            assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+            assertEquals(30, p.getIntValue());
+            assertToken(JsonToken.END_OBJECT, p.nextToken());
+            assertToken(JsonToken.END_OBJECT, p.nextToken());
+            assertNull(p.nextToken());
+        }
+
+        JsonNode node = MAPPER.readTree(YAML);
+        assertTrue(node.has("[user, 123]"));
+        assertEquals("Ivan", node.get("[user, 123]").get("name").asString());
+        assertEquals(30, node.get("[user, 123]").get("age").asInt());
+    }
+
+    @Test
+    public void testComplexMappingKeyMapping() throws Exception
+    {
+        final String YAML = "? {foo: bar}\n: 42\n";
+        try (JsonParser p = MAPPER.createParser(YAML)) {
+            assertToken(JsonToken.START_OBJECT, p.nextToken());
+            assertToken(JsonToken.PROPERTY_NAME, p.nextToken());
+            assertEquals("{foo: bar}", p.currentName());
+            assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+            assertEquals(42, p.getIntValue());
+            assertToken(JsonToken.END_OBJECT, p.nextToken());
+            assertNull(p.nextToken());
+        }
+    }
+
     // In Jackson 3.x, non-Number token should NOT throw exception for parser.getNumberType()
     // (like in 2.x) but just return `null`
     private void _verifyGetNumberTypeFail(JsonParser p, String token) throws Exception