gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/language/translator/DotNetTranslateVisitor.d.cts

@@ -0,0 +1,166 @@
+import TranslateVisitor from './TranslateVisitor.cjs';
+/**
+ * Converts a Gremlin traversal string into a C# source code representation.
+ * Mirrors the Java DotNetTranslateVisitor.
+ */
+export default class DotNetTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName?: string);
+    protected processGremlinSymbol(step: string): string;
+    protected getCardinalityFunctionClass(): string;
+    /**
+     * .NET enum values are capitalized but do NOT go through processGremlinSymbol,
+     * since the SymbolHelper mappings (bigdecimal→BigDecimal etc.) don't apply to enums.
+     */
+    protected appendExplicitNaming(txt: string, prefix: string): void;
+    visitTraversalGType(ctx: any): void;
+    visitTraversalDirection(ctx: any): void;
+    visitTraversalDirectionShort(ctx: any): void;
+    visitTraversalDirectionLong(ctx: any): void;
+    visitNanLiteral(_ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitDateLiteral(ctx: any): void;
+    visitGenericRangeLiteral(_ctx: any): void;
+    visitGenericSetLiteral(ctx: any): void;
+    visitGenericCollectionLiteral(ctx: any): void;
+    visitGenericMapLiteral(ctx: any): void;
+    visitMapEntry(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitClassType(ctx: any): void;
+    visitTraversalStrategy(ctx: any): void;
+    visitConfiguration(ctx: any): void;
+    visitStringNullableArgumentVarargs(ctx: any): void;
+    private handleGenerics;
+    private handleLongArguments;
+    private tryAppendCastToLong_IntArg;
+    private tryAppendCastToString_StringArg;
+    private visitStringArgumentVarargsWithCast;
+    private tryAppendCastToString_StringNullableLit;
+    private tryAppendCastToString_StringNullableArg;
+    private tryAppendCastToObject_GenericArg;
+    private tryAppendCastToObject_GenericLit;
+    private isCalledAsFirstStepInAnonymousTraversal;
+    visitTraversalSourceSpawnMethod_inject(ctx: any): void;
+    visitTraversalSourceSpawnMethod_io(ctx: any): void;
+    visitTraversalSourceSpawnMethod_union(ctx: any): void;
+    visitTraversalSourceSpawnMethod_call_empty(ctx: any): void;
+    visitTraversalSourceSpawnMethod_match_string(ctx: any): void;
+    visitTraversalSourceSpawnMethod_match_string_map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_addV_String(ctx: any): void;
+    visitTraversalSourceSpawnMethod_addE(ctx: any): void;
+    visitTraversalSourceSpawnMethod_call_string(ctx: any): void;
+    visitTraversalSourceSpawnMethod_call_string_map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_call_string_traversal(ctx: any): void;
+    visitTraversalSourceSpawnMethod_call_string_map_traversal(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeV_Map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeV_Traversal(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeE_Map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeE_Traversal(ctx: any): void;
+    visitTraversalMethod_asString_Scope(ctx: any): void;
+    visitTraversalMethod_branch(ctx: any): void;
+    visitTraversalMethod_cap(ctx: any): void;
+    visitTraversalMethod_choose_Function(ctx: any): void;
+    visitTraversalMethod_choose_Predicate_Traversal(ctx: any): void;
+    visitTraversalMethod_choose_Predicate_Traversal_Traversal(ctx: any): void;
+    visitTraversalMethod_choose_Traversal(ctx: any): void;
+    visitTraversalMethod_choose_Traversal_Traversal(ctx: any): void;
+    visitTraversalMethod_choose_Traversal_Traversal_Traversal(ctx: any): void;
+    visitTraversalMethod_coalesce(ctx: any): void;
+    visitTraversalMethod_constant(ctx: any): void;
+    visitTraversalMethod_elementMap(ctx: any): void;
+    visitTraversalMethod_flatMap(ctx: any): void;
+    visitTraversalMethod_fold_Empty(ctx: any): void;
+    visitTraversalMethod_fold_Object_BiFunction(ctx: any): void;
+    visitTraversalMethod_group_Empty(ctx: any): void;
+    visitTraversalMethod_groupCount_Empty(ctx: any): void;
+    visitTraversalMethod_index(ctx: any): void;
+    visitTraversalMethod_length_Scope(ctx: any): void;
+    visitTraversalMethod_local(ctx: any): void;
+    visitTraversalMethod_lTrim_Scope(ctx: any): void;
+    visitTraversalMethod_map(ctx: any): void;
+    visitTraversalMethod_match_traversal(ctx: any): void;
+    visitTraversalMethod_match_string(ctx: any): void;
+    visitTraversalMethod_match_string_map(ctx: any): void;
+    visitTraversalMethod_max_Empty(ctx: any): void;
+    visitTraversalMethod_max_Scope(ctx: any): void;
+    visitTraversalMethod_mean_Empty(ctx: any): void;
+    visitTraversalMethod_mean_Scope(ctx: any): void;
+    visitTraversalMethod_min_Empty(ctx: any): void;
+    visitTraversalMethod_min_Scope(ctx: any): void;
+    visitTraversalMethod_optional(ctx: any): void;
+    visitTraversalMethod_profile_Empty(ctx: any): void;
+    visitTraversalMethod_project(ctx: any): void;
+    visitTraversalMethod_properties(ctx: any): void;
+    visitTraversalMethod_propertyMap(ctx: any): void;
+    visitTraversalMethod_replace_Scope_String_String(ctx: any): void;
+    visitTraversalMethod_rTrim_Scope(ctx: any): void;
+    visitTraversalMethod_sack_Empty(ctx: any): void;
+    visitTraversalMethod_select_Column(ctx: any): void;
+    visitTraversalMethod_select_Pop_String(ctx: any): void;
+    visitTraversalMethod_select_Pop_String_String_String(ctx: any): void;
+    visitTraversalMethod_select_Pop_Traversal(ctx: any): void;
+    visitTraversalMethod_select_String(ctx: any): void;
+    visitTraversalMethod_select_String_String_String(ctx: any): void;
+    visitTraversalMethod_select_Traversal(ctx: any): void;
+    visitTraversalMethod_split_Scope_String(ctx: any): void;
+    visitTraversalMethod_substring_Scope_int(ctx: any): void;
+    visitTraversalMethod_substring_Scope_int_int(ctx: any): void;
+    visitTraversalMethod_sum_Empty(ctx: any): void;
+    visitTraversalMethod_sum_Scope(ctx: any): void;
+    visitTraversalMethod_tail_Empty(ctx: any): void;
+    visitTraversalMethod_tail_Scope(ctx: any): void;
+    visitTraversalMethod_toLower_Scope(ctx: any): void;
+    visitTraversalMethod_toUpper_Scope(ctx: any): void;
+    visitTraversalMethod_tree_Empty(ctx: any): void;
+    visitTraversalMethod_trim_Scope(ctx: any): void;
+    visitTraversalMethod_unfold(ctx: any): void;
+    visitTraversalMethod_union(ctx: any): void;
+    visitTraversalMethod_value(ctx: any): void;
+    visitTraversalMethod_valueMap_String(ctx: any): void;
+    visitTraversalMethod_valueMap_boolean_String(ctx: any): void;
+    visitTraversalMethod_values(ctx: any): void;
+    visitTraversalMethod_limit_long(ctx: any): void;
+    visitTraversalMethod_limit_Scope_long(ctx: any): void;
+    visitTraversalMethod_range_long_long(ctx: any): void;
+    visitTraversalMethod_range_Scope_long_long(ctx: any): void;
+    visitTraversalMethod_skip_long(ctx: any): void;
+    visitTraversalMethod_skip_Scope_long(ctx: any): void;
+    visitTraversalMethod_tail_long(ctx: any): void;
+    visitTraversalMethod_tail_Scope_long(ctx: any): void;
+    visitTraversalMethod_addV_String(ctx: any): void;
+    visitTraversalMethod_addE_String(ctx: any): void;
+    visitTraversalMethod_call_string(ctx: any): void;
+    visitTraversalMethod_call_string_map(ctx: any): void;
+    visitTraversalMethod_call_string_traversal(ctx: any): void;
+    visitTraversalMethod_call_string_map_traversal(ctx: any): void;
+    visitTraversalMethod_has_String_Object(ctx: any): void;
+    visitTraversalMethod_has_String_P(ctx: any): void;
+    visitTraversalMethod_has_String_String_Object(ctx: any): void;
+    visitTraversalMethod_has_String_String_P(ctx: any): void;
+    visitTraversalMethod_has_T_Object(ctx: any): void;
+    visitTraversalMethod_has_T_P(ctx: any): void;
+    visitTraversalMethod_hasKey_P(ctx: any): void;
+    visitTraversalMethod_hasKey_String_String(ctx: any): void;
+    visitTraversalMethod_hasValue_Object_Object(ctx: any): void;
+    visitTraversalMethod_hasValue_P(ctx: any): void;
+    visitTraversalMethod_hasLabel_P(ctx: any): void;
+    visitTraversalMethod_hasLabel_String_String(ctx: any): void;
+    visitTraversalMethod_mergeV_Map(ctx: any): void;
+    visitTraversalMethod_mergeV_Traversal(ctx: any): void;
+    visitTraversalMethod_mergeE_Map(ctx: any): void;
+    visitTraversalMethod_mergeE_Traversal(ctx: any): void;
+    visitTraversalMethod_option_Merge_Map(ctx: any): void;
+    visitTraversalMethod_option_Merge_Traversal(ctx: any): void;
+    visitTraversalMethod_option_Object_Traversal(ctx: any): void;
+    visitTraversalMethod_property_Object(ctx: any): void;
+    visitTraversalMethod_property_Cardinality_Object(ctx: any): void;
+    visitTraversalMethod_property_Traversal(ctx: any): void;
+    visitTraversalMethod_property_Cardinality_Object_Object_Object(ctx: any): void;
+    visitTraversalMethod_conjoin_String(ctx: any): void;
+    private tryAppendCastToString_StringLit;
+}

package/build/cjs/language/translator/GoTranslateVisitor.cjs

@@ -0,0 +1,421 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Context parameters are typed as `any` because the generated grammar files
+// require accepting arbitrary context types at runtime.
+const TranslateVisitor_js_1 = __importDefault(require("./TranslateVisitor.cjs"));
+const TranslatorException_js_1 = require("./TranslatorException.cjs");
+const buffer_1 = require("node:buffer");
+const GO_PACKAGE_NAME = 'gremlingo.';
+const STRATEGY_WITH_MAP_OPTS = new Set([
+    'OptionsStrategy',
+    'ReferenceElementStrategy', 'ComputerFinalizationStrategy', 'ProfileStrategy',
+    'ComputerVerificationStrategy', 'StandardVerificationStrategy', 'VertexProgramRestrictionStrategy',
+    'MessagePassingReductionStrategy',
+]);
+const STRATEGY_WITH_STRING_SLICE = new Set([
+    'ReservedKeysVerificationStrategy', 'ProductiveByStrategy',
+]);
+/**
+ * Converts a Gremlin traversal string into a Go source code representation.
+ * Assumes use of the gremlingo, math, time, and uuid packages.
+ */
+class GoTranslateVisitor extends TranslateVisitor_js_1.default {
+    constructor(graphTraversalSourceName = 'g') {
+        super(graphTraversalSourceName);
+    }
+    processGremlinSymbol(step) {
+        return SymbolHelper.toGo(step);
+    }
+    getCardinalityFunctionClass() {
+        return 'CardinalityValue';
+    }
+    appendExplicitNaming(txt, prefix) {
+        this.sb.push(GO_PACKAGE_NAME);
+        super.appendExplicitNaming(txt, prefix);
+    }
+    appendAnonymousSpawn() {
+        this.sb.push(GO_PACKAGE_NAME + 'T__.');
+    }
+    visitP(ctx, pClass, methodName) {
+        this.sb.push(GO_PACKAGE_NAME);
+        super.visitP(ctx, pClass, methodName);
+    }
+    visitTraversalGType(ctx) {
+        const parts = ctx.getText().split('.');
+        this.sb.push(GO_PACKAGE_NAME);
+        this.sb.push(this.processGremlinSymbol(parts[0]));
+        this.sb.push('.');
+        this.sb.push(this.processGremlinSymbol(parts[1].toLowerCase()));
+    }
+    visitNanLiteral(_ctx) {
+        this.sb.push('math.NaN()');
+    }
+    visitInfLiteral(ctx) {
+        if (ctx.SignedInfLiteral() != null && ctx.SignedInfLiteral().getText() === '-Infinity') {
+            this.sb.push('math.Inf(-1)');
+        }
+        else {
+            this.sb.push('math.Inf(1)');
+        }
+    }
+    visitNullLiteral(_ctx) {
+        this.sb.push('nil');
+    }
+    visitStringNullableLiteral(ctx) {
+        if (ctx.getText() === 'null') {
+            this.sb.push('nil');
+        }
+        else {
+            const text = TranslateVisitor_js_1.default.removeFirstAndLastCharacters(ctx.getText());
+            this.handleStringLiteralText(text);
+        }
+    }
+    visitIntegerLiteral(ctx) {
+        const integerLiteral = ctx.getText().toLowerCase();
+        const lastChar = integerLiteral[integerLiteral.length - 1];
+        const num = integerLiteral.slice(0, -1);
+        if (!/[a-z]/.test(lastChar)) {
+            this.sb.push(integerLiteral);
+            return;
+        }
+        switch (lastChar) {
+            case 'b':
+                this.sb.push('int8(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 's':
+                this.sb.push('int16(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 'i':
+                this.sb.push('int32(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 'l':
+                this.sb.push('int64(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 'n':
+                this.sb.push(GO_PACKAGE_NAME + 'ParseBigInt("');
+                this.sb.push(num);
+                this.sb.push('")');
+                break;
+            default:
+                this.sb.push(integerLiteral);
+        }
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        const floatLiteral = ctx.getText().toLowerCase();
+        const lastChar = floatLiteral[floatLiteral.length - 1];
+        const num = floatLiteral.slice(0, -1);
+        if (!/[a-z]/.test(lastChar)) {
+            this.sb.push(floatLiteral);
+            return;
+        }
+        switch (lastChar) {
+            case 'f':
+                this.sb.push('float32(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 'd':
+                this.sb.push(num);
+                break;
+            case 'm':
+                this.sb.push(GO_PACKAGE_NAME + 'ParseBigDecimal("');
+                this.sb.push(num);
+                this.sb.push('")');
+                break;
+            default:
+                this.sb.push(floatLiteral);
+        }
+    }
+    visitDateLiteral(ctx) {
+        const dtString = ctx.getChild(2).getText();
+        const inner = TranslateVisitor_js_1.default.removeFirstAndLastCharacters(dtString);
+        const d = new Date(inner);
+        if (isNaN(d.getTime())) {
+            throw new TranslatorException_js_1.TranslatorException(`Invalid datetime: ${inner}`);
+        }
+        const year = d.getUTCFullYear();
+        const month = d.getUTCMonth() + 1;
+        const day = d.getUTCDate();
+        const hours = d.getUTCHours();
+        const minutes = d.getUTCMinutes();
+        const seconds = d.getUTCSeconds();
+        const nanos = d.getUTCMilliseconds() * 1_000_000;
+        const totalSeconds = 0; // assume UTC when no offset specified
+        const zoneInfo = 'UTC+00:00';
+        this.sb.push(`time.Date(${year}, ${month}, ${day}, ${hours}, ${minutes}, ${seconds}, ${nanos}, time.FixedZone("${zoneInfo}", ${totalSeconds}))`);
+    }
+    visitGenericRangeLiteral(_ctx) {
+        throw new TranslatorException_js_1.TranslatorException('Go does not support range literals');
+    }
+    visitGenericSetLiteral(ctx) {
+        this.sb.push(GO_PACKAGE_NAME + 'NewSimpleSet(');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push(')');
+    }
+    visitGenericCollectionLiteral(ctx) {
+        this.sb.push('[]interface{}{');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push('}');
+    }
+    visitGenericMapLiteral(ctx) {
+        this.sb.push('map[interface{}]interface{}{');
+        const entries = ctx.mapEntry();
+        for (let i = 0; i < entries.length; i++) {
+            this.visit(entries[i]);
+            if (i < entries.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push(' }');
+    }
+    visitMapEntry(ctx) {
+        this.visit(ctx.mapKey());
+        this.sb.push(': ');
+        this.visit(ctx.genericLiteral());
+    }
+    visitMapKey(ctx) {
+        const keyIndex = (ctx.LPAREN() != null && ctx.RPAREN() != null) ? 1 : 0;
+        this.visit(ctx.getChild(keyIndex));
+    }
+    visitUuidLiteral(ctx) {
+        if (ctx.stringLiteral() == null) {
+            this.sb.push('uuid.New()');
+            return;
+        }
+        this.sb.push('uuid.MustParse(');
+        this.visitStringLiteral(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitCharacterLiteral(_ctx) {
+        throw new TranslatorException_js_1.TranslatorException('Character literals are not supported in Go');
+    }
+    visitDurationLiteral(ctx) {
+        const seconds = parseInt(ctx.integerLiteral(0).getText(), 10);
+        const nanos = parseInt(ctx.integerLiteral(1).getText(), 10);
+        const isPositive = ctx.booleanLiteral() === null ||
+            ctx.booleanLiteral().getText() === 'true';
+        // Use BigInt to avoid precision loss for durations over ~104 days
+        const totalNanos = BigInt(seconds) * 1000000000n + BigInt(nanos);
+        this.sb.push(`time.Duration(${isPositive ? totalNanos : -totalNanos})`);
+    }
+    visitBinaryLiteral(ctx) {
+        const base64Str = TranslateVisitor_js_1.default.removeFirstAndLastCharacters(ctx.stringLiteral().getText());
+        const bytes = base64ToBytes(base64Str);
+        this.sb.push(GO_PACKAGE_NAME + 'ByteBuffer{Data: []byte{');
+        for (let i = 0; i < bytes.length; i++) {
+            if (i > 0)
+                this.sb.push(',');
+            this.sb.push(String(bytes[i]));
+        }
+        this.sb.push('}}');
+    }
+    visitTraversalTerminalMethod_next(ctx) {
+        // Go has no method overloading: next() maps to Next(), next(n) maps to NextN(n)
+        if (ctx.getChildCount() === 4) {
+            this.sb.push('NextN(');
+            this.visit(ctx.getChild(2));
+            this.sb.push(')');
+        }
+        else {
+            this.sb.push('Next()');
+        }
+    }
+    visitTraversalStrategy(ctx) {
+        if (ctx.getChildCount() === 1) {
+            this.sb.push(GO_PACKAGE_NAME);
+            this.sb.push(ctx.getText());
+            this.sb.push('()');
+            return;
+        }
+        const firstText = ctx.getChild(0).getText();
+        const strategyName = firstText === 'new' ? ctx.getChild(1).getText() : firstText;
+        this.sb.push(GO_PACKAGE_NAME);
+        this.sb.push(strategyName);
+        this.sb.push('(');
+        if (!STRATEGY_WITH_MAP_OPTS.has(strategyName)) {
+            this.sb.push(GO_PACKAGE_NAME);
+            this.sb.push(strategyName);
+            this.sb.push('Config{');
+        }
+        const configs = ctx.configuration();
+        for (let ix = 0; ix < configs.length; ix++) {
+            this.visit(configs[ix]);
+            if (ix < configs.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        if (strategyName !== 'OptionsStrategy') {
+            this.sb.push('}');
+        }
+        this.sb.push(')');
+    }
+    visitConfiguration(ctx) {
+        const parent = ctx.parent.getText();
+        const parenIdx = parent.indexOf('(');
+        const rawName = parenIdx > -1 ? parent.substring(0, parenIdx) : parent;
+        const parentName = rawName.startsWith('new') ? rawName.substring(3) : rawName;
+        if (STRATEGY_WITH_MAP_OPTS.has(parentName)) {
+            this.sb.push('map[string]interface{}{"');
+            this.sb.push(ctx.getChild(0).getText());
+            this.sb.push('": ');
+            this.visit(ctx.getChild(2));
+            this.sb.push('}');
+            return;
+        }
+        const key = ctx.getChild(0).getText();
+        this.sb.push(SymbolHelper.toGo(key));
+        this.sb.push(': ');
+        const startIdx = this.sb.length;
+        this.visit(ctx.genericArgument());
+        if (STRATEGY_WITH_STRING_SLICE.has(parentName)) {
+            // Replace []interface{} with []string if present
+            const idx = this.sb.indexOf('[]interface{}', startIdx);
+            if (idx > -1) {
+                this.sb[idx] = '[]string';
+            }
+        }
+        if (key === 'readPartitions') {
+            // Replace []interface{}{items} with gremlingo.NewSimpleSet(items)
+            const added = this.sb.splice(startIdx);
+            const joined = added.join('');
+            const transformed = joined.replace(/^\[\]interface\{\}\{([\s\S]*)\}$/, GO_PACKAGE_NAME + 'NewSimpleSet($1)');
+            this.sb.push(transformed);
+        }
+    }
+    visitTraversalSourceSpawnMethod_match_string(ctx) {
+        this.sb.push('Match(');
+        this.visit(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitTraversalSourceSpawnMethod_match_string_map(ctx) {
+        this.sb.push('Match(');
+        this.visit(ctx.stringLiteral());
+        this.sb.push(', ');
+        this.visitGoParamsMap(ctx.genericMapLiteral());
+        this.sb.push(')');
+    }
+    visitTraversalMethod_match_string(ctx) {
+        this.sb.push('Match(');
+        this.visit(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitTraversalMethod_match_string_map(ctx) {
+        this.sb.push('Match(');
+        this.visit(ctx.stringLiteral());
+        this.sb.push(', ');
+        this.visitGoParamsMap(ctx.genericMapLiteral());
+        this.sb.push(')');
+    }
+    visitGoParamsMap(mapLiteral) {
+        this.sb.push('map[string]interface{}{');
+        const entries = mapLiteral.mapEntry();
+        for (let i = 0; i < entries.length; i++) {
+            this.visit(entries[i]);
+            if (i < entries.length - 1)
+                this.sb.push(', ');
+        }
+        this.sb.push(' }');
+    }
+    visitTraversalSourceSelfMethod_withoutStrategies(ctx) {
+        this.sb.push('WithoutStrategies(');
+        this.sb.push(GO_PACKAGE_NAME);
+        this.sb.push(ctx.classType().getText());
+        this.sb.push('()');
+        if (ctx.classTypeList() != null && ctx.classTypeList().classTypeExpr() != null) {
+            for (const classTypeCtx of ctx.classTypeList().classTypeExpr().classType()) {
+                this.sb.push(', ');
+                this.sb.push(GO_PACKAGE_NAME);
+                this.sb.push(classTypeCtx.getText());
+                this.sb.push('()');
+            }
+        }
+        this.sb.push(')');
+    }
+}
+exports.default = GoTranslateVisitor;
+/**
+ * Decodes a base64 string into an array of unsigned byte values.
+ */
+function base64ToBytes(base64) {
+    if (base64 === '')
+        return [];
+    const buf = buffer_1.Buffer.from(base64, 'base64');
+    const bytes = new Array(buf.length);
+    for (let i = 0; i < buf.length; i++) {
+        bytes[i] = buf[i];
+    }
+    return bytes;
+}
+class SymbolHelper {
+    static TO_GO_MAP = {
+        'OUT': 'Out',
+        'IN': 'In',
+        'BOTH': 'Both',
+        'bigdecimal': 'BigDecimal',
+        'bigint': 'BigInt',
+        'datetime': 'DateTime',
+        'uuid': 'UUID',
+        'vproperty': 'VProperty',
+        'WithOptions': GO_PACKAGE_NAME + 'WithOptions',
+        'IO': GO_PACKAGE_NAME + 'IO',
+        '__': GO_PACKAGE_NAME + 'T__',
+    };
+    static toGo(symbol) {
+        if (symbol in SymbolHelper.TO_GO_MAP) {
+            return SymbolHelper.TO_GO_MAP[symbol];
+        }
+        // Capitalize first letter (mirrors Java StringUtils.capitalize)
+        if (!symbol)
+            return symbol;
+        return symbol.charAt(0).toUpperCase() + symbol.slice(1);
+    }
+}

package/build/cjs/language/translator/GoTranslateVisitor.d.cts

@@ -0,0 +1,40 @@
+import TranslateVisitor from './TranslateVisitor.cjs';
+/**
+ * Converts a Gremlin traversal string into a Go source code representation.
+ * Assumes use of the gremlingo, math, time, and uuid packages.
+ */
+export default class GoTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName?: string);
+    protected processGremlinSymbol(step: string): string;
+    protected getCardinalityFunctionClass(): string;
+    protected appendExplicitNaming(txt: string, prefix: string): void;
+    protected appendAnonymousSpawn(): void;
+    protected visitP(ctx: any, pClass: string, methodName: string): void;
+    visitTraversalGType(ctx: any): void;
+    visitNanLiteral(_ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitNullLiteral(_ctx: any): void;
+    visitStringNullableLiteral(ctx: any): void;
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitDateLiteral(ctx: any): void;
+    visitGenericRangeLiteral(_ctx: any): void;
+    visitGenericSetLiteral(ctx: any): void;
+    visitGenericCollectionLiteral(ctx: any): void;
+    visitGenericMapLiteral(ctx: any): void;
+    visitMapEntry(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(_ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitTraversalTerminalMethod_next(ctx: any): void;
+    visitTraversalStrategy(ctx: any): void;
+    visitConfiguration(ctx: any): void;
+    visitTraversalSourceSpawnMethod_match_string(ctx: any): void;
+    visitTraversalSourceSpawnMethod_match_string_map(ctx: any): void;
+    visitTraversalMethod_match_string(ctx: any): void;
+    visitTraversalMethod_match_string_map(ctx: any): void;
+    private visitGoParamsMap;
+    visitTraversalSourceSelfMethod_withoutStrategies(ctx: any): void;
+}