Add noreferences linter #163

krishagarwal278 · 2025-10-27T20:08:03Z

Added a new references linter to enforce that API field names use Ref/Refs suffixes instead of Reference/References.

What it does:

Flags fields ending with Reference and suggests changing to Ref
Flags fields ending with References and suggests changing to Refs

Fixes #25

linux-foundation-easycla · 2025-10-27T20:08:10Z

The committers listed above are authorized under a signed CLA.

✅ login: krishagarwal278 / name: Krish Agarwal (6fd4884, a0366ad)

k8s-ci-robot · 2025-10-27T20:08:12Z

Welcome @krishagarwal278!

It looks like this is your first PR to kubernetes-sigs/kube-api-linter 🎉. Please refer to our pull request process documentation to help your PR have a smooth ride to approval.

You will be prompted by a bot to use commands during the review process. Do not be afraid to follow the prompts! It is okay to experiment. Here is the bot commands documentation.

You can also check if kubernetes-sigs/kube-api-linter has its own contribution guidelines.

You may want to refer to our testing guide if you run into trouble with your tests not passing.

If you are having difficulty getting your pull request seen, please follow the recommended escalation practices. Also, for tips and tricks in the contribution process you may want to read the Kubernetes contributor cheat sheet. We want to make sure your contribution gets all the attention it needs!

Thank you, and welcome to Kubernetes. 😃

JoelSpeed

This is a great start, thanks for your contribution!

JoelSpeed · 2025-10-28T10:18:13Z

docs/linters.md

+```yaml
+lintersConfig:
+  references:
+    allowRefAndRefs: false | true # Allow Ref/Refs suffixes for OpenShift compatibility. Defaults to `false`.


We generally prefer enums over bools, so maybe lets change this to be more like policy config like we have in other places. Perhaps the values could be AllowRefAndRefs and ForbidRefAndRefs?

Nit: Let's also drop the OpenShift mention. This is a vendor-neutral project.

yes i agree. Having policy config in an enum would make a lot more sense. Incorporated in latest commit 👍🏻

JoelSpeed · 2025-10-28T10:19:08Z

docs/linters.md

+**OpenShift compatibility (allowRefAndRefs=true):**
+- Reports errors for fields ending with 'Reference' or 'References'  
+- Allows fields ending with 'Ref' or 'Refs' without reporting errors


In this mode we want to also report Ref and Refs and drop all of these

JoelSpeed · 2025-10-28T10:20:26Z

pkg/analysis/references/testdata/src/a/a.go

@@ -0,0 +1,22 @@
+package a
+
+type TestSpec struct {


Can you try some field names where they contain the string ref/refs or reference/references but not at the end? Eg Prefix or Prefereneces perhaps could be in field names?

across both 'a' and 'b' test files i incorporated tests for prefix, suffix, middle of the field and edge cases 👍🏻

JoelSpeed · 2025-10-28T10:21:56Z

pkg/analysis/references/analyzer.go

+func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, jsonTagInfo extractjsontags.FieldTagInfo) {
+	if field == nil || len(field.Names) == 0 {
+		return
+	}
+
+	fieldName := utils.FieldName(field)
+
+	if strings.HasSuffix(fieldName, "Reference") {
+		suggestedName := strings.TrimSuffix(fieldName, "Reference") + "Ref"
+		pass.Report(analysis.Diagnostic{
+			Pos:     field.Pos(),
+			Message: fmt.Sprintf("field %s should use 'Ref' instead of 'Reference'", fieldName),
+			SuggestedFixes: []analysis.SuggestedFix{
+				{
+					Message: "replace 'Reference' with 'Ref'",
+					TextEdits: []analysis.TextEdit{
+						{
+							Pos:     field.Names[0].Pos(),
+							NewText: []byte(suggestedName),
+							End:     field.Names[0].End(),
+						},
+					},
+				},
+			},
+		})
+		return
+	}
+
+	if strings.HasSuffix(fieldName, "References") {
+		suggestedName := strings.TrimSuffix(fieldName, "References") + "Refs"
+		pass.Report(analysis.Diagnostic{
+			Pos:     field.Pos(),
+			Message: fmt.Sprintf("field %s should use 'Refs' instead of 'References'", fieldName),
+			SuggestedFixes: []analysis.SuggestedFix{
+				{
+					Message: "replace 'References' with 'Refs'",
+					TextEdits: []analysis.TextEdit{
+						{
+							Pos:     field.Names[0].Pos(),
+							NewText: []byte(suggestedName),
+							End:     field.Names[0].End(),
+						},
+					},
+				},
+			},
+		})
+		return
+	}
+
+	// If allowRefAndRefs is false, report errors for standalone Ref/Refs fields
+	// If allowRefAndRefs is true (OpenShift), don't report errors for Ref/Refs fields
+	if !a.allowRefAndRefs {
+		// Check for fields ending with Ref or Refs (excluding those already handled above)
+		if fieldName != "Ref" && strings.HasSuffix(fieldName, "Ref") && !strings.HasSuffix(fieldName, "eRef") {
+			pass.Reportf(field.Pos(), "field %s should not use 'Ref' suffix", fieldName)
+		}
+
+		if fieldName != "Refs" && strings.HasSuffix(fieldName, "Refs") && !strings.HasSuffix(fieldName, "eRefs") {
+			pass.Reportf(field.Pos(), "field %s should not use 'Refs' suffix", fieldName)
+		}
+	}
+}


This is all very well written, but, take a look at the namingconventions linter. I believe we can implement this linter as a wrapper around that linter just by providing it with fixed configuration based on the config rules for this particular linter.

pkg/analysis/references/analyzer_test.go

JoelSpeed · 2025-10-28T10:23:34Z

pkg/analysis/noreferences/doc.go

+lintersConfig:
+
+	references: {}
+


NIt, probably best to remove the blank lines in these code blocks

Not yet actioned

JoelSpeed · 2025-10-28T10:24:02Z

pkg/analysis/references/initializer.go

+
+// validateConfig validates the configuration for the references linter.
+func validateConfig(cfg *Config, fldPath *field.Path) field.ErrorList {
+	// No validation needed for this simple config


If we switch to an enum, I'd expect some validation here FWIW

policy validation incorporated 👍🏻

JoelSpeed · 2025-10-28T10:24:49Z

.golangci.yaml

    - govet
    - importas
    - ineffassign
+    - kubeapilinter


Reverted that change 👍🏻 can't have kubeapilinter as a linter itself for this project 😆

Was testing out/exploring different files in the linter and so might've committed this as a change too

sivchari

I want more test cases about references linter. And you mention OpenShift, but I think kube-api-linter should provide better practices for all developer who design Kubernetes API. Though original issue says OpenShift, I think it's better to publish this linter more general.

sivchari · 2025-10-28T13:48:31Z

docs/linters.md

+- Reports errors for fields ending with 'Reference' or 'References'
+- Also reports errors for fields ending with 'Ref' or 'Refs' (unless they were corrected from Reference/References)
+
+**OpenShift compatibility (allowRefAndRefs=true):**


OpenShift compatibility

Is this unique problem with OpenShift ? Other projects might use this option, so I suggest to rename this to more general.

Not unique to Openshift. Removed mention 👍🏻

sivchari · 2025-10-28T13:59:59Z

pkg/analysis/references/analyzer.go

+		if fieldName != "Ref" && strings.HasSuffix(fieldName, "Ref") && !strings.HasSuffix(fieldName, "eRef") {
+			pass.Reportf(field.Pos(), "field %s should not use 'Ref' suffix", fieldName)
+		}
+
+		if fieldName != "Refs" && strings.HasSuffix(fieldName, "Refs") && !strings.HasSuffix(fieldName, "eRefs") {
+			pass.Reportf(field.Pos(), "field %s should not use 'Refs' suffix", fieldName)
+		}


What is eRef and eRefs ? why do we check the field with it ? Isn't it enough to only check Ref or Refs ?
I want some examples for test.

replaced the initially added condition to check for letters/patterns before or after. Incorporated edge cases in test files 👍🏻

sivchari · 2025-10-28T14:05:27Z

docs/linters.md

+
+**Default behavior (allowRefAndRefs=false):**
+- Reports errors for fields ending with 'Reference' or 'References'
+- Also reports errors for fields ending with 'Ref' or 'Refs' (unless they were corrected from Reference/References)


It says “suffix,” but does that mean it doesn't allow fields named Ref or Refs?

removed "suffix" as we are replacing instances of 'Reference' and 'References' anywhere across the field. beginning(prefix), middle, end

JoelSpeed · 2025-10-30T16:29:52Z

docs/linters.md

+
+The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
+
+By default, `references` is enabled and operates in strict mode, prohibiting the use of 'Reference', 'References', 'Ref', or 'Refs' anywhere in field names


Default should be to allow Ref/Refs, but not Reference/References

JoelSpeed · 2025-10-30T16:30:27Z

docs/linters.md

+```
+
+**Default behavior (policy: ForbidRefAndRefs):**
+- Reports errors for fields containing 'Reference' or 'References' anywhere and suggests replacing with 'Ref' or 'Refs'


Why would it suggest to replace with something that it will then report is bad?

Yikes, i guess I misunderstood the default policy to be forbidRefAndRefs. It's now allowRefAndRefs which makes sense because we want to allow Ref and Refs but not Reference and References as the default configuration option

JoelSpeed · 2025-10-30T16:31:31Z

pkg/analysis/namingconventions/analyzer.go

+// NewAnalyzer creates a new analysis.Analyzer for the namingconventions
 // linter based on the provided config.
-func newAnalyzer(cfg *Config) *analysis.Analyzer {
+// This function is exported to allow other linters to wrap namingconventions
+// with fixed configuration.
+func NewAnalyzer(cfg *Config) *analysis.Analyzer {


Are we certain this needs to be changed to exported? I thought we avoided that on the other PR

Ahh nice catch. Guess we can avoid it here too!

JoelSpeed · 2025-10-30T16:36:01Z

pkg/analysis/references/analyzer.go

+			// Match "Refs" but not when part of "References"
+			namingconventions.Convention{
+				Name:             "forbid-refs",
+				ViolationMatcher: "Refs([^a-z]|$)",


Refs would not be part of references? I don't think the extra capture is needed here is it?

this was part of forbidRefAndRefs policy

JoelSpeed · 2025-10-30T16:37:24Z

pkg/analysis/references/analyzer.go

+
+	// If policy is ForbidRefAndRefs, add conventions to forbid Ref/Refs anywhere
+	// Exclude patterns already handled by Reference/References above
+	if policy == PolicyForbidRefAndRefs {


I think it might make sense rather to append, to look into replace the list in this case (probably switch on the valid values?) and then look at how you could regex Reference Ref References and Refs` in a single regex for the drop

Appending into a single regex for this makes so much sense!

Agreed, a single regex makes sense here.

JoelSpeed · 2025-10-30T16:40:03Z

pkg/analysis/references/initializer.go

+	var errs field.ErrorList
+
+	// Validate Policy enum if provided
+	if cfg.Policy != "" && cfg.Policy != PolicyAllowRefAndRefs && cfg.Policy != PolicyForbidRefAndRefs {


Better to use a switch here and have the default case error

JoelSpeed · 2025-10-30T16:40:25Z

pkg/analysis/noreferences/doc.go

+lintersConfig:
+
+	references: {}
+


Not yet actioned

JoelSpeed · 2025-10-30T16:40:39Z

pkg/analysis/references/config.go

+
+// Config represents the configuration for the references linter.
+type Config struct {
+	// Policy controls whether Ref/Refs are allowed or forbidden in field names.


For consistency with other rules

Suggested change

// Policy controls whether Ref/Refs are allowed or forbidden in field names.

// policy controls whether Ref/Refs are allowed or forbidden in field names.

JoelSpeed · 2025-10-30T16:42:16Z

pkg/analysis/references/testdata/src/a/a.go.golden

+	ConfigRefs []string `json:"configRefs"` // want `naming convention "references-to-refs": field ConfigReferences: field names should use 'Refs' instead of 'References'`
+
+	// Fields with Reference at beginning should be flagged
+	RefCount int `json:"referenceCount"` // want `naming convention "reference-to-ref": field ReferenceCount: field names should use 'Ref' instead of 'Reference'`


Should it not also have fixed the json?

When testing locally, it's also fixing json. Latest commit has the new version of the file 👍🏻

JoelSpeed · 2025-10-30T16:44:13Z

pkg/analysis/references/analyzer.go

+			namingconventions.Convention{
+				Name:             "forbid-refs",
+				ViolationMatcher: "Refs([^a-z]|$)",
+				Operation:        namingconventions.OperationInform,


Should this be a Drop rather than inform?

I think we should just inform here because user wants to flag / forbidRefAndRefs they may not necessarily want to drop that substring itself.
For eg: We might not want NodeRef --> Node

dropping/swapping out ref(s) could be in scope for another story 👍🏻

Ack, happy to have this as inform for now, will see if we get any feedback about it

Not sure I agree here. I think intention behind forbidRefAndRefs is actually to cause something like NodeRef -> Node.

If we think there is a reasonable use case to inform instead of suggest fixes, maybe we follow configuration precedence of other linters to allow a Warn and SuggestFixes configuration for this linter and we default to SuggestFixes?

krishagarwal278 · 2025-10-30T17:40:55Z

/label tide/merge-method-squash

JoelSpeed · 2025-10-31T11:09:49Z

docs/linters.md

 - **Allows** fields containing 'Ref' or 'Refs' without reporting errors

+**Strict mode (policy: ForbidRefAndRefs):**
+- Reports errors for fields containing 'Reference' or 'References' anywhere and suggests replacing with 'Ref' or 'Refs'


This behaviour feels wrong still, suggesting to replace something that will then flag again?

+1, this should be dropping of the offending text.

@JoelSpeed @everettraven if y'all agree to dropping Ref/s too as offending text in ForbidRefAndRefs, can certainly make that change 👍🏻

JoelSpeed · 2025-10-31T11:10:17Z

docs/linters.md

 - `NodeReferences` → `NodeRefs`

-Note: In the default `ForbidRefAndRefs` mode, these fixes are intermediate - the linter will still report errors on the resulting 'Ref'/'Refs' patterns, indicating they should be removed entirely
+Note: In the `ForbidRefAndRefs` mode, the fixes are intermediate. As, the linter will still report errors on the resulting 'Ref'/'Refs' patterns, indicating they should be removed entirely


I think we can avoid this

JoelSpeed · 2025-10-31T11:11:49Z

pkg/analysis/references/analyzer.go

+	conventions := []namingconventions.Convention{
+		{
+			Name:             "reference-to-ref",
+			ViolationMatcher: "(?i)reference(s?)",


Why do we make this case insensitive? Isn't that causing things like Preference to become Prefs, I don't think that's actually desired? I think we are better not having the case insensitivity aren't we?

Hmm. That's a good question - I can't remember if removing the case sensitivity would mean we don't update the serialized form of the name correctly or not.

Would be good to double check that. If it still handles serialized name updates correctly, I agree we can put this back to being case sensitive.

Doing that means we do miss cases where the field name casing is incorrect though like Podreferences.

I wonder if adding a linter specifically for field name being PascalCase would make sense and consider something like Podreferences to be out of scope here?

+1 @JoelSpeed i agree on making it case sensitive. Currently we are getting false positives as its converting Preference to Prefs which is documented as a known limitation.
@everettraven Circling back to our last discussion on PascalCase i still do feel that adding another linter for field name being PascalCase would make most sense.

We can possibly flag instances likePodreferences, referenceCount here to say field has invalid casing.

@krishagarwal278 Could you verify that removing the case insensitivity results in successfully matching the json tags that look like reference* and *Reference?

JoelSpeed · 2025-10-31T11:12:29Z

pkg/analysis/references/analyzer.go

+	// If policy is ForbidRefAndRefs, also flag Ref/Refs as problematic (no fix provided)
+	// This creates a two-step hint: fix Reference→Ref, but know that Ref also needs changing
+	if policy == PolicyForbidRefAndRefs {
+		conventions = append(conventions,


I think this wants to replace, not append. That way we can avoid the intermediate steps.

Should be able to just have a single regex here I think

JoelSpeed · 2025-10-31T11:12:50Z

pkg/analysis/references/analyzer.go

+			namingconventions.Convention{
+				Name:             "forbid-refs",
+				ViolationMatcher: "Refs([^a-z]|$)",
+				Operation:        namingconventions.OperationInform,


Ack, happy to have this as inform for now, will see if we get any feedback about it

pkg/analysis/noreferences/analyzer.go

everettraven · 2025-10-31T11:41:41Z

docs/linters.md

+```yaml
+lintersConfig:
+  references:
+    policy: AllowRefAndRefs | ForbidRefAndRefs # Defaults to `AllowRefAndRefs`.


Probably more of a nitpick, but I wonder if something like PreferAbbreviatedReference and NoReference might be a bit more intuitive naming from the end-user perspective?

Naming suggestion works for me

Nit: I think @JoelSpeed i agreed on something like PreferAbbreviatedReference and NoReferences

everettraven · 2025-10-31T11:42:51Z

docs/linters.md

 - **Allows** fields containing 'Ref' or 'Refs' without reporting errors

+**Strict mode (policy: ForbidRefAndRefs):**
+- Reports errors for fields containing 'Reference' or 'References' anywhere and suggests replacing with 'Ref' or 'Refs'


+1, this should be dropping of the offending text.

everettraven · 2025-10-31T11:51:47Z

pkg/analysis/references/analyzer.go

+	conventions := []namingconventions.Convention{
+		{
+			Name:             "reference-to-ref",
+			ViolationMatcher: "(?i)reference(s?)",


Hmm. That's a good question - I can't remember if removing the case sensitivity would mean we don't update the serialized form of the name correctly or not.

Would be good to double check that. If it still handles serialized name updates correctly, I agree we can put this back to being case sensitive.

Doing that means we do miss cases where the field name casing is incorrect though like Podreferences.

I wonder if adding a linter specifically for field name being PascalCase would make sense and consider something like Podreferences to be out of scope here?

everettraven · 2025-10-31T11:56:21Z

pkg/analysis/references/analyzer.go

+
+	// If policy is ForbidRefAndRefs, add conventions to forbid Ref/Refs anywhere
+	// Exclude patterns already handled by Reference/References above
+	if policy == PolicyForbidRefAndRefs {


Agreed, a single regex makes sense here.

everettraven · 2025-10-31T11:59:56Z

pkg/analysis/references/analyzer.go

+			namingconventions.Convention{
+				Name:             "forbid-refs",
+				ViolationMatcher: "Refs([^a-z]|$)",
+				Operation:        namingconventions.OperationInform,


Not sure I agree here. I think intention behind forbidRefAndRefs is actually to cause something like NodeRef -> Node.

If we think there is a reasonable use case to inform instead of suggest fixes, maybe we follow configuration precedence of other linters to allow a Warn and SuggestFixes configuration for this linter and we default to SuggestFixes?

everettraven · 2025-10-31T12:07:38Z

docs/linters.md


+## References
+
+The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.


It looks like we've established a pattern that for linters associated with a "don't do this" semantic we prefix with no.

I think staying consistent would be good, so I wonder if this should instead be noreference?

@JoelSpeed what are your thoughts here?

Yeah I think that makes sense, noreference or noreferences

The only pushback I can think of on that, is that the others are forbidding the usage of certain types. Which means this one forbidding just the naming might be a bit different? Does it imply that you aren't allowed reference types vs fields with references in the name?

We have nophase and notimestamp which are naming conventions

Ok, @krishagarwal278 can you rename this to noreferences please

JoelSpeed · 2025-11-03T10:32:12Z

pkg/analysis/references/analyzer.go

+		}
+
+	default:
+		// Should not happen due to validation, but return PreferAbbreviatedReference conventions as fallback


In this case it's suitable to panic

JoelSpeed · 2025-11-03T10:34:12Z

pkg/analysis/references/testdata/src/a/a.go

+
+	// Edge cases - Preference contains "reference" and WILL be flagged with (?i)
+	// This is intentional to catch all variations including malformed casing
+	PreferenceType string `json:"preferenceType"` // want `naming convention "reference-to-ref": field PreferenceType: field names should use 'Ref' instead of 'Reference'`


I think using an adaptation of the regex for the prefer abbreviated functionality, we should be able to avoid this edge case.

Think about how we can require upper or lower at the beginning (^) vs requiring upper when not at the beginning

Right @everettraven ? I think that's what you were aiming for

JoelSpeed · 2025-11-03T10:36:34Z

pkg/analysis/references/analyzer.go

+		return []namingconventions.Convention{
+			{
+				Name:             "no-references",
+				ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])|([Rr]ef(?:erence)?s?)$",


Suggested change

ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])|([Rr]ef(?:erence)?s?)$",

ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])|(Ref(?:erence)?s?)$",

Shouldn't the second part of this not be case insensitive?

Yeah possibly. Do you also suggest making the first part case insensitive for consistency?

I believe the first part is deliberate to pick up fields starting with Reference, cc @everettraven since I think he came up with this regex

This doesn't look quite like the one I came up with, but you probably want 2 variants here based on the configured policy (i.e preferring Ref vs none at all).

If you prefer Ref(s), it should look something like:

^[Rr]eferences?|References?$

The first half of the expression, ^[Rr]eferences?, will match any fields that follow the pattern Reference*, References*, reference*, and References*.

The second half of the expression, References?$ will match any fields that follow the pattern *Reference and *References. This prevents if from picking up things like *Preferences because it doesn't match on the lowercase r.

If want neither Ref nor References, it should look something like:

^[Rr]ef(erence)?s?|Ref(erence)?s?$

This does generally the same thing as the previous expression, but makes the erence part of Reference optional in the matching. That means it will additionally match Ref*, ref*, Refs*, refs*, *Ref, and *Refs.

JoelSpeed · 2025-11-03T10:36:53Z

docs/linters.md


+## References
+
+The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.


Ok, @krishagarwal278 can you rename this to noreferences please

JoelSpeed · 2025-11-04T13:39:11Z

docs/linters.md

 - [Notimestamp](#notimestamp) - Prevents usage of 'TimeStamp' fields
 - [OptionalFields](#optionalfields) - Validates optional field conventions
 - [OptionalOrRequired](#optionalorrequired) - Ensures fields are explicitly marked as optional or required
+- [References](#references) - Ensures field names use Ref/Refs instead of Reference/References


Suggested change

- [References](#references) - Ensures field names use Ref/Refs instead of Reference/References

- [NoReferences](#noreferences) - Ensures field names use Ref/Refs instead of Reference/References

JoelSpeed · 2025-11-04T13:53:09Z

pkg/analysis/noreferences/analyzer.go

+
+	case PolicyNoReferences:
+		// Drop any reference-related words from field names
+		// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($2)


Suggested change

// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($2)

// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($3)

JoelSpeed · 2025-11-04T13:53:32Z

pkg/analysis/noreferences/analyzer.go

+		// When at start, $2 captures and preserves the next uppercase letter
+		// When at end, $2 is empty, effectively dropping the text


Suggested change

// When at start, $2 captures and preserves the next uppercase letter

// When at end, $2 is empty, effectively dropping the text

// When at start, $3 captures and preserves the next uppercase letter

// When at end, $3 is empty, effectively dropping the text

JoelSpeed · 2025-11-04T13:56:29Z

pkg/analysis/noreferences/doc.go

+lintersConfig:
+
+	noreferences:
+	  policy: PreferAbbreviatedReference
+


Suggested change

lintersConfig:

noreferences:

policy: PreferAbbreviatedReference

lintersConfig:

noreferences:

policy: PreferAbbreviatedReference

JoelSpeed · 2025-11-04T13:56:48Z

pkg/analysis/noreferences/doc.go

+
+	noreferences:
+	  policy: NoReferences
+


Suggested change

noreferences:

policy: NoReferences

noreferences:

policy: NoReferences

formatting for the markdown codeblock is finicky. didn't realize closing the file after making changes, will autosaved and added that extra line again but it's adding some extra indentation on lintersConfig. I replaced it with multi-line comment to preserve my changes 👍🏻

JoelSpeed · 2025-11-04T13:57:47Z

golangci-lint-kube-api-linter

This should not be committed

JoelSpeed · 2025-11-04T13:59:44Z

docs/linters.md

+  - `RefNode` → `Node` (start)
+  - `NodeRef` → `Node` (end)
+  - `ReferenceName` → `Name` (start)
+  - `ConfigReferences` → `Config` (end)


Looking at the test, I believe the s is preserved isn't it?

currently we're not preserving s because References to a Config can't change to Configs. At the moment we're dropping reference/references but it doesn't impact/change Config itself.

Another example from the b.go and b.go.golden

- ContainerRefs []string `json:"containerRefs"` - Container []string `json:"container"` // want `naming convention "no-references": field ContainerRefs: field names should not contain reference-related words`

JoelSpeed · 2025-11-04T15:52:06Z

pkg/analysis/noreferences/analyzer.go

+				Name:             "reference-to-ref",
+				ViolationMatcher: "^[Rr]eference(s?)|Reference(s?)$",
+				Operation:        namingconventions.OperationReplacement,
+				Replacement:      "Ref$1$2",


There's only 1 capture group in the regex isn't there? Should be this?

Suggested change

Replacement: "Ref$1$2",

Replacement: "Ref$1",

JoelSpeed · 2025-11-06T13:10:38Z

/lgtm
/approve

k8s-ci-robot · 2025-11-06T13:10:46Z

[APPROVALNOTIFIER] This PR is APPROVED

This pull-request has been approved by: JoelSpeed, krishagarwal278

The full list of commands accepted by this bot can be found here.

The pull request process is described here

Needs approval from an approver in each of these files:

~~OWNERS~~ [JoelSpeed]

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

JoelSpeed · 2025-11-06T16:33:33Z

pkg/analysis/noreferences/analyzer.go

+	case PolicyPreferAbbreviatedReference:
+		// Replace "Reference" or "References" with "Ref" or "Refs" anywhere in field name
+		// Case insensitive to handle lowercase in JSON tags
+		// Note: May produce false positives like "Preference" → "PRef", but this is acceptable


I think this line is not actually true anymore

JoelSpeed · 2025-11-06T17:29:25Z

/lgtm

JoelSpeed · 2025-11-06T17:32:15Z

tests/integration/testdata/default_configurations/object_references.go

@@ -1,6 +1,9 @@
 package defaultconfigurations

-import "k8s.io/apimachinery/pkg/types"


This change appears to have broken the integration tests

everettraven · 2025-11-06T18:45:47Z

/ok-to-test

everettraven

One minor comment on the go doc for the linter.

Other than that, this LGTM.

@krishagarwal278 mentioned that tagging with an LGTM seems to kick the GHA workflows - giving this a shot. If this merges with the documentation comment we can follow up with a PR to fix it.

/lgtm

everettraven · 2025-11-06T18:58:37Z

pkg/analysis/noreferences/doc.go

+/*
+The `noreferences` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
+By default, `noreferences` is enabled and enforces this naming convention.
+The linter checks that 'Reference' anywhere in field names (beginning, middle, or end) is replaced with 'Ref'.


Only beginning and end right?

everettraven · 2025-11-06T19:02:28Z

Doesn't look like that is the case.

/lgtm cancel

k8s-ci-robot requested review from everettraven and jpbetz October 27, 2025 20:08

krishagarwal278 force-pushed the KAL-25 branch from a2cce44 to 4e54c0c Compare October 27, 2025 20:36

JoelSpeed reviewed Oct 28, 2025

View reviewed changes

sivchari reviewed Oct 28, 2025

View reviewed changes

k8s-ci-robot added size/XL Denotes a PR that changes 500-999 lines, ignoring generated files. and removed size/L Denotes a PR that changes 100-499 lines, ignoring generated files. labels Oct 29, 2025

JoelSpeed reviewed Oct 30, 2025

View reviewed changes

k8s-ci-robot added the tide/merge-method-squash Denotes a PR that should be squashed by tide when it merges. label Oct 30, 2025

JoelSpeed reviewed Oct 31, 2025

View reviewed changes

everettraven reviewed Oct 31, 2025

View reviewed changes

JoelSpeed reviewed Nov 3, 2025

View reviewed changes

JoelSpeed reviewed Nov 4, 2025

View reviewed changes

krishagarwal278 force-pushed the KAL-25 branch 2 times, most recently from 3fe6ca1 to e910b22 Compare November 4, 2025 15:22

JoelSpeed reviewed Nov 4, 2025

View reviewed changes

k8s-ci-robot assigned JoelSpeed Nov 6, 2025

k8s-ci-robot added the lgtm "Looks good to me", indicates that a PR is ready to be merged. label Nov 6, 2025

k8s-ci-robot added approved Indicates a PR has been approved by an approver from all required OWNERS files. and removed lgtm "Looks good to me", indicates that a PR is ready to be merged. labels Nov 6, 2025

krishagarwal278 force-pushed the KAL-25 branch from d55c401 to 9b85f8b Compare November 6, 2025 14:44

krishagarwal278 force-pushed the KAL-25 branch from 9b85f8b to 7afeb87 Compare November 6, 2025 14:44

krishagarwal278 changed the title ~~Add references linter~~ Add noreferences linter Nov 6, 2025

JoelSpeed reviewed Nov 6, 2025

View reviewed changes

krishagarwal278 force-pushed the KAL-25 branch from 7afeb87 to 4ab5c7c Compare November 6, 2025 17:05

k8s-ci-robot added needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. and removed needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. labels Nov 6, 2025

k8s-ci-robot added the lgtm "Looks good to me", indicates that a PR is ready to be merged. label Nov 6, 2025

JoelSpeed reviewed Nov 6, 2025

View reviewed changes

krishagarwal278 force-pushed the KAL-25 branch from ca49477 to 7078b02 Compare November 6, 2025 17:35

k8s-ci-robot added needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. and removed lgtm "Looks good to me", indicates that a PR is ready to be merged. labels Nov 6, 2025

krishagarwal278 force-pushed the KAL-25 branch from 7078b02 to 360add3 Compare November 6, 2025 17:36

k8s-ci-robot removed the needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. label Nov 6, 2025

krishagarwal278 force-pushed the KAL-25 branch from fc1d183 to 360add3 Compare November 6, 2025 18:19

k8s-ci-robot added needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. and removed needs-rebase Indicates a PR cannot be merged because it has merge conflicts with HEAD. labels Nov 6, 2025

k8s-ci-robot added the ok-to-test Indicates a non-member PR verified by an org member that is safe to test. label Nov 6, 2025

everettraven reviewed Nov 6, 2025

View reviewed changes

k8s-ci-robot assigned everettraven Nov 6, 2025

k8s-ci-robot added the lgtm "Looks good to me", indicates that a PR is ready to be merged. label Nov 6, 2025

k8s-ci-robot removed the lgtm "Looks good to me", indicates that a PR is ready to be merged. label Nov 6, 2025

krishagarwal278 force-pushed the KAL-25 branch from 299b4b0 to e6f037a Compare November 6, 2025 20:45

Added noreferences linter

6fd4884

krishagarwal278 force-pushed the KAL-25 branch from e6f037a to 6fd4884 Compare November 6, 2025 20:48

Fixed integration tests

a0366ad


		The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.

		By default, `references` is enabled and operates in strict mode, prohibiting the use of 'Reference', 'References', 'Ref', or 'Refs' anywhere in field names

	// Policy controls whether Ref/Refs are allowed or forbidden in field names.
	// policy controls whether Ref/Refs are allowed or forbidden in field names.


		## References

		The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.

	ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])\|([Rr]ef(?:erence)?s?)$",
	ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])\|(Ref(?:erence)?s?)$",

	- [References](#references) - Ensures field names use Ref/Refs instead of Reference/References
	- [NoReferences](#noreferences) - Ensures field names use Ref/Refs instead of Reference/References

	// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($2)
	// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($3)

		// When at start, $2 captures and preserves the next uppercase letter
		// When at end, $2 is empty, effectively dropping the text

		@@ -1,6 +1,9 @@
		package defaultconfigurations

		import "k8s.io/apimachinery/pkg/types"

Add noreferences linter #163

Are you sure you want to change the base?

Add noreferences linter #163

Conversation

krishagarwal278 commented Oct 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

linux-foundation-easycla bot commented Oct 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

k8s-ci-robot commented Oct 27, 2025

Uh oh!

JoelSpeed left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sivchari left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

krishagarwal278 commented Oct 27, 2025 •

edited

Loading

linux-foundation-easycla bot commented Oct 27, 2025 •

edited

Loading