chore: remove dead functions — 3 functions removed (#32411)

Author: github-actions[bot]

pkg/cli/compile_compiler_setup_test.go

@@ -82,11 +82,3 @@ func TestSetupRepositoryContext_ScheduleSeedTakesPrecedenceOverPerFileRemote(t *
 		t.Fatalf("--schedule-seed should take precedence over per-file remote; expected upstream/repo, got %q", got)
 	}
 }
-
-func TestCreateAndConfigureCompiler_ForceStaged(t *testing.T) {
-	compiler := createAndConfigureCompiler(CompileConfig{Staged: true})
-
-	if !compiler.IsForceStaged() {
-		t.Fatal("expected --staged compiler configuration to force staged mode")
-	}
-}

pkg/workflow/compiler_types.go

@@ -49,12 +49,6 @@ func WithVersion(version string) CompilerOption {
 	return func(c *Compiler) { c.version = version }
 }
 
-// WithContext sets the context used for network operations such as SHA resolution.
-// Defaults to context.Background() if not specified.
-func WithContext(ctx context.Context) CompilerOption {
-	return func(c *Compiler) { c.ctx = ctx }
-}
-
 // FileCreationTracker interface for tracking files created during compilation
 type FileCreationTracker interface {
 	TrackCreated(filePath string)
@@ -194,11 +188,6 @@ func (c *Compiler) SetForceStaged(force bool) {
 	c.forceStaged = force
 }
 
-// IsForceStaged reports whether the compiler forces safe-outputs into staged mode.
-func (c *Compiler) IsForceStaged() bool {
-	return c.forceStaged
-}
-
 // SetFileTracker sets the file tracker for tracking created files
 func (c *Compiler) SetFileTracker(tracker FileCreationTracker) {
 	c.fileTracker = tracker

pkg/workflow/template_injection_validation.go

@@ -76,23 +76,6 @@ func hasAnyExpressionInRunContent(yamlContent string) bool {
 	return hasExpressionInRunContent(yamlContent, inlineExpressionRegex)
 }
 
-// hasUnsafeExpressionInRunContent performs a fast line-by-line text scan to determine
-// whether any unsafe context expression (${{ github.event.* }},
-// ${{ steps.*.outputs.* }}, or ${{ inputs.* }}) appears inside the content of a
-// YAML run: block.
-//
-// This is used as an efficient pre-flight check in generateAndValidateYAML.
-// Most compiler-generated workflows place unsafe expressions only in env: values
-// (the compiler's normal output pattern), so the expensive full YAML parse for
-// template-injection validation can be skipped in the common case.
-//
-// The scanner is intentionally lightweight rather than fully conservative: when it
-// encounters `run:` with no inline content (rest == ""), it enters run-block scanning
-// mode and only returns true if a subsequent indented line matches unsafeContextRegex.
-func hasUnsafeExpressionInRunContent(yamlContent string) bool {
-	return hasExpressionInRunContent(yamlContent, unsafeContextRegex)
-}
-
 func hasExpressionInRunContent(yamlContent string, expressionRegex *regexp.Regexp) bool {
 	// Fast-path: no matching expressions anywhere → definitely no violation.
 	if !expressionRegex.MatchString(yamlContent) {

pkg/workflow/template_injection_validation_test.go

@@ -1298,152 +1298,3 @@ func TestTemplateInjectionYAMLParsingEdgeCases(t *testing.T) {
 		})
 	}
 }
-
-// TestHasUnsafeExpressionInRunContent tests the fast text-based pre-flight check
-// that gates full YAML parsing in generateAndValidateYAML.
-func TestHasUnsafeExpressionInRunContent(t *testing.T) {
-	tests := []struct {
-		name     string
-		yaml     string
-		expected bool
-		desc     string
-	}{
-		{
-			name:     "empty yaml",
-			yaml:     "",
-			expected: false,
-			desc:     "empty input has no violations",
-		},
-		{
-			name: "no unsafe expressions",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: echo "hello"`,
-			expected: false,
-			desc:     "no unsafe expressions anywhere",
-		},
-		{
-			name: "unsafe expression only in env block - common compiler pattern",
-			yaml: `jobs:
-  test:
-    steps:
-      - name: Step
-        env:
-          VALUE: ${{ github.event.issue.title }}
-        run: |
-          echo "$VALUE"`,
-			expected: false,
-			desc:     "compiler puts expressions in env: blocks, not run: – no violation",
-		},
-		{
-			name: "unsafe expression in concurrency group - not in run block",
-			yaml: `concurrency:
-  group: "ci-${{ github.event.pull_request.number }}"
-jobs:
-  test:
-    steps:
-      - name: Step
-        env:
-          PR: ${{ github.event.pull_request.number }}
-        run: |
-          echo "$PR"`,
-			expected: false,
-			desc:     "expressions in concurrency.group are not in run: blocks",
-		},
-		{
-			name: "unsafe expression directly in inline run value",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: echo "${{ github.event.issue.title }}"`,
-			expected: true,
-			desc:     "direct expression use in inline run: is unsafe",
-		},
-		{
-			name: "unsafe expression in block scalar run content",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: |
-          echo "${{ github.event.issue.title }}"`,
-			expected: true,
-			desc:     "direct expression use in run: block scalar is unsafe",
-		},
-		{
-			name: "unsafe expression in folded block run content",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: >
-          echo "${{ github.event.issue.title }}"`,
-			expected: true,
-			desc:     "direct expression use in run: folded block is unsafe",
-		},
-		{
-			name: "unsafe expression in steps outputs context",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: |
-          echo "${{ steps.prior.outputs.data }}"`,
-			expected: true,
-			desc:     "steps.outputs expression in run: is unsafe",
-		},
-		{
-			name: "unsafe expression in inputs context",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: |
-          echo "${{ inputs.user_data }}"`,
-			expected: true,
-			desc:     "inputs expression in run: is unsafe",
-		},
-		{
-			name: "expression in env block above run block - not in run content",
-			yaml: `jobs:
-  test:
-    steps:
-      - name: Multi-step with env
-        env:
-          A: ${{ github.event.issue.title }}
-          B: ${{ steps.prior.outputs.val }}
-        run: |
-          echo "$A $B"
-      - run: echo "done"`,
-			expected: false,
-			desc:     "expressions in env: before run: are not inside run: content",
-		},
-		{
-			name: "multiple steps - only one has unsafe run content",
-			yaml: `jobs:
-  test:
-    steps:
-      - env:
-          V: ${{ github.event.issue.title }}
-        run: echo "$V"
-      - run: |
-          echo "${{ github.event.issue.title }}"`,
-			expected: true,
-			desc:     "second step has unsafe expression directly in run: block",
-		},
-		{
-			name: "chomping indicator |- still detected",
-			yaml: `jobs:
-  test:
-    steps:
-      - run: |-
-          echo "${{ github.event.issue.title }}"`,
-			expected: true,
-			desc:     "chomping indicators don't prevent detection",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := hasUnsafeExpressionInRunContent(tt.yaml)
-			assert.Equal(t, tt.expected, got, tt.desc)
-		})
-	}
-}