@herb-tools/linter 0.8.9 → 0.9.0

package/src/rules/erb-no-duplicate-branch-elements.ts

@@ -0,0 +1,320 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { IdentityPrinter } from "@herb-tools/printer"
+
+import {
+  isHTMLElementNode,
+  isERBIfNode,
+  isERBElseNode,
+  isERBUnlessNode,
+  isERBCaseNode,
+  isERBWhenNode,
+  isEquivalentElement,
+  isPureWhitespaceNode,
+  findParentArray,
+  removeNodeFromArray,
+  replaceNodeWithBody,
+  createLiteral,
+  HTMLElementNode,
+  Location,
+} from "@herb-tools/core"
+
+import type { BaseAutofixContext, UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, Node, ERBIfNode, ERBUnlessNode, ERBCaseNode, ERBElseNode } from "@herb-tools/core"
+import type { Mutable } from "@herb-tools/rewriter"
+
+type ConditionalNode = ERBIfNode | ERBUnlessNode | ERBCaseNode
+
+interface DuplicateBranchAutofixContext extends BaseAutofixContext {
+  node: Mutable<ConditionalNode>
+}
+
+function getSignificantNodes(statements: Node[]): Node[] {
+  return statements.filter(node => !isPureWhitespaceNode(node))
+}
+
+function allEquivalentElements(nodes: Node[]): nodes is HTMLElementNode[] {
+  if (nodes.length < 2) return false
+  if (!nodes.every(node => isHTMLElementNode(node))) return false
+
+  const first = nodes[0]
+
+  return nodes.slice(1).every(node => isEquivalentElement(first, node as HTMLElementNode))
+}
+
+function collectBranchesFromIf(node: ERBIfNode): Node[][] | null {
+  const branches: Node[][] = []
+  let current: ERBIfNode | ERBElseNode | null = node.subsequent
+
+  branches.push(node.statements)
+
+  while (current) {
+    if (isERBElseNode(current)) {
+      branches.push(current.statements)
+      return branches
+    }
+
+    if (isERBIfNode(current)) {
+      branches.push(current.statements)
+      current = current.subsequent
+    } else {
+      break
+    }
+  }
+
+  return null
+}
+
+function collectBranchesFromUnless(node: ERBUnlessNode): Node[][] | null {
+  if (!node.else_clause) return null
+
+  return [node.statements, node.else_clause.statements]
+}
+
+function collectBranchesFromCase(node: ERBCaseNode): Node[][] | null {
+  if (!node.else_clause) return null
+
+  const branches: Node[][] = []
+
+  for (const condition of node.conditions) {
+    if (isERBWhenNode(condition)) {
+      branches.push(condition.statements)
+    }
+  }
+
+  branches.push(node.else_clause.statements)
+
+  return branches
+}
+
+function collectBranches(node: ConditionalNode): Node[][] | null {
+  if (isERBIfNode(node)) return collectBranchesFromIf(node)
+  if (isERBUnlessNode(node)) return collectBranchesFromUnless(node)
+  if (isERBCaseNode(node)) return collectBranchesFromCase(node)
+
+  return null
+}
+
+function findCommonPrefixCount(branches: Node[][], minLength: number): number {
+  let count = 0
+
+  for (let index = 0; index < minLength; index++) {
+    const nodesAtIndex = branches.map(branch => branch[index])
+
+    if (allEquivalentElements(nodesAtIndex)) {
+      count++
+    } else {
+      break
+    }
+  }
+
+  return count
+}
+
+function findCommonSuffixCount(branches: Node[][], minLength: number, prefixCount: number): number {
+  let count = 0
+
+  for (let offset = 0; offset < minLength - prefixCount; offset++) {
+    const nodesAtOffset = branches.map(branch => branch[branch.length - 1 - offset])
+
+    if (allEquivalentElements(nodesAtOffset)) {
+      count++
+    } else {
+      break
+    }
+  }
+
+  return count
+}
+
+function createWrapper(template: HTMLElementNode, body: Node[]): HTMLElementNode {
+  return new HTMLElementNode({
+    type: "AST_HTML_ELEMENT_NODE",
+    open_tag: template.open_tag,
+    tag_name: template.tag_name,
+    body,
+    close_tag: template.close_tag,
+    is_void: template.is_void,
+    element_source: template.element_source,
+    location: Location.zero,
+    errors: [],
+  })
+}
+
+class ERBNoDuplicateBranchElementsVisitor extends BaseRuleVisitor<DuplicateBranchAutofixContext> {
+  private processedIfNodes = new Set<Node>()
+
+  visitERBIfNode(node: ERBIfNode): void {
+    if (this.processedIfNodes.has(node)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    this.checkConditionalNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitERBUnlessNode(node: ERBUnlessNode): void {
+    this.checkConditionalNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.checkConditionalNode(node)
+    this.visitChildNodes(node)
+  }
+
+  private checkConditionalNode(node: ConditionalNode): void {
+    const branches = collectBranches(node)
+    if (!branches) return
+
+    if (isERBIfNode(node)) {
+      this.markSubsequentIfNodesAsProcessed(node)
+    }
+
+    const state = { isFirstOffense: true }
+    this.checkBranches(branches, node, state)
+  }
+
+  private markSubsequentIfNodesAsProcessed(node: ERBIfNode): void {
+    let current: ERBIfNode | ERBElseNode | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        this.processedIfNodes.add(current)
+        current = current.subsequent
+      } else {
+        break
+      }
+    }
+  }
+
+  private checkBranches(branches: Node[][], conditionalNode: ConditionalNode, state: { isFirstOffense: boolean }): void {
+    const significantBranches = branches.map(getSignificantNodes)
+    if (significantBranches.some(branch => branch.length === 0)) return
+
+    const minLength = Math.min(...significantBranches.map(branch => branch.length))
+    const prefixCount = findCommonPrefixCount(significantBranches, minLength)
+    const suffixCount = findCommonSuffixCount(significantBranches, minLength, prefixCount)
+
+    for (let index = 0; index < prefixCount; index++) {
+      const elements = significantBranches.map(branch => branch[index] as HTMLElementNode)
+      this.reportAndRecurse(elements, conditionalNode, state)
+    }
+
+    for (let offset = 0; offset < suffixCount; offset++) {
+      const elements = significantBranches.map(branch => branch[branch.length - 1 - offset] as HTMLElementNode)
+      this.reportAndRecurse(elements, conditionalNode, state)
+    }
+  }
+
+  private reportAndRecurse(elements: HTMLElementNode[], conditionalNode: ConditionalNode, state: { isFirstOffense: boolean }): void {
+    const bodies = elements.map(element => element.body)
+    const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]))
+
+    for (const element of elements) {
+      const printed = IdentityPrinter.print(element.open_tag)
+      const autofixContext = state.isFirstOffense
+        ? { node: conditionalNode as Mutable<ConditionalNode> }
+        : undefined
+
+      this.addOffense(
+        `The \`${printed}\` element is duplicated across all branches of this conditional and can be moved outside.`,
+        bodiesMatch ? element.location : (element?.open_tag?.location || element.location),
+        autofixContext,
+      )
+
+      state.isFirstOffense = false
+    }
+
+    if (!bodiesMatch && bodies.every(body => body.length > 0)) {
+      this.checkBranches(bodies, conditionalNode, state)
+    }
+  }
+}
+
+export class ERBNoDuplicateBranchElementsRule extends ParserRule<DuplicateBranchAutofixContext> {
+  static ruleName = "erb-no-duplicate-branch-elements"
+  static autocorrectable = true
+  static reindentAfterAutofix = true
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning",
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<DuplicateBranchAutofixContext>[] {
+    const visitor = new ERBNoDuplicateBranchElementsVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<DuplicateBranchAutofixContext>, result: ParseResult): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const conditionalNode = offense.autofixContext.node
+    const branches = collectBranches(conditionalNode as ConditionalNode)
+    if (!branches) return null
+
+    const significantBranches = branches.map(getSignificantNodes)
+    if (significantBranches.some(branch => branch.length === 0)) return null
+
+    const minLength = Math.min(...significantBranches.map(branch => branch.length))
+    const prefixCount = findCommonPrefixCount(significantBranches, minLength)
+    const suffixCount = findCommonSuffixCount(significantBranches, minLength, prefixCount)
+
+    if (prefixCount === 0 && suffixCount === 0) return null
+
+    const parentInfo = findParentArray(result.value, conditionalNode as unknown as Node)
+    if (!parentInfo) return null
+
+    let { array: parentArray, index: conditionalIndex } = parentInfo
+    let hasWrapped = false
+
+    const hoistElement = (elements: HTMLElementNode[], position: "before" | "after"): void => {
+      const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]))
+
+      if (bodiesMatch) {
+        for (let i = 0; i < branches.length; i++) {
+          removeNodeFromArray(branches[i] as Node[], elements[i])
+        }
+
+        if (position === "before") {
+          parentArray.splice(conditionalIndex, 0, elements[0])
+          conditionalIndex++
+        } else {
+          parentArray.splice(conditionalIndex + 1, 0, elements[0])
+        }
+      } else {
+        if (hasWrapped) return
+
+        for (let i = 0; i < branches.length; i++) {
+          replaceNodeWithBody(branches[i] as Node[], elements[i])
+        }
+
+        const wrapper = createWrapper(elements[0], [createLiteral("\n"), conditionalNode as unknown as Node, createLiteral("\n")])
+
+        parentArray[conditionalIndex] = wrapper
+        parentArray = wrapper.body as Node[]
+        conditionalIndex = 1
+        hasWrapped = true
+      }
+    }
+
+    for (let index = 0; index < prefixCount; index++) {
+      const elements = significantBranches.map(branch => branch[index] as HTMLElementNode)
+      hoistElement(elements, "before")
+    }
+
+    for (let offset = 0; offset < suffixCount; offset++) {
+      const elements = significantBranches.map(branch => branch[branch.length - 1 - offset] as HTMLElementNode)
+      hoistElement(elements, "after")
+    }
+
+    return result
+  }
+}

package/src/rules/erb-no-empty-tags.ts

@@ -22,7 +22,7 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
 }
 
 export class ERBNoEmptyTagsRule extends ParserRule {
-  name = "erb-no-empty-tags"
+  static ruleName = "erb-no-empty-tags"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -32,7 +32,7 @@ export class ERBNoEmptyTagsRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
+    const visitor = new ERBNoEmptyTagsVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/erb-no-extra-newline.ts

@@ -1,8 +1,7 @@
-import { BaseSourceRuleVisitor } from "./rule-utils.js"
-import { SourceRule } from "../types.js"
-import { Location, Position } from "@herb-tools/core"
+import { type Node, Location } from "@herb-tools/core"
 
-import type { Node } from "@herb-tools/core"
+import { BaseSourceRuleVisitor, positionFromOffset } from "./rule-utils.js"
+import { SourceRule } from "../types.js"
 import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, FullRuleConfig } from "../types.js"
 
 interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
@@ -10,25 +9,6 @@ interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
   endOffset: number
 }
 
-function positionFromOffset(source: string, offset: number): Position {
-  let line = 1
-  let column = 0
-  let currentOffset = 0
-
-  for (let i = 0; i < source.length && currentOffset < offset; i++) {
-    const char = source[i]
-    currentOffset++
-    if (char === "\n") {
-      line++
-      column = 0
-    } else {
-      column++
-    }
-  }
-
-  return new Position(line, column)
-}
-
 class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor<ERBNoExtraNewLineAutofixContext> {
   protected visitSource(source: string): void {
     if (source.length === 0) return
@@ -61,7 +41,7 @@ class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor<ERBNoExtraNewLineAu
 
 export class ERBNoExtraNewLineRule extends SourceRule {
   static autocorrectable = true
-  name = "erb-no-extra-newline"
+  static ruleName = "erb-no-extra-newline"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -71,7 +51,7 @@ export class ERBNoExtraNewLineRule extends SourceRule {
   }
 
   check(source: string, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new ERBNoExtraNewLineVisitor(this.name, context)
+    const visitor = new ERBNoExtraNewLineVisitor(this.ruleName, context)
 
     visitor.visit(source)
 

package/src/rules/erb-no-extra-whitespace-inside-tags.ts

@@ -3,7 +3,7 @@ import { BaseRuleVisitor } from "./rule-utils.js"
 
 import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
 import { Location } from "@herb-tools/core"
-import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, LintSeverity, FullRuleConfig } from "../types.js"
 
 interface ERBNoExtraWhitespaceAutofixContext extends BaseAutofixContext {
   node: Mutable<ERBNode>
@@ -26,11 +26,24 @@ class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor<ERBNoExtraWh
       this.reportWhitespace(node, openTag, closeTag, value, "start", 0, `Remove extra whitespace after \`${openTag.value}\`.`, "after-open")
     }
 
-    if (openTag.value === "<%#" && value.startsWith("=") && value.length > 1) {
-      const afterEquals = value.substring(1)
-
-      if (afterEquals.match(/^\s{2,}/) && !afterEquals.startsWith("  \n") && !afterEquals.startsWith("\n")) {
-        this.reportWhitespace(node, openTag, closeTag, value, "start", 1, `Remove extra whitespace after \`<%#=\`.`, "after-comment-equals")
+    if (openTag.value === "<%#") {
+      const prefix = this.getCommentedTagPrefix(value)
+
+      if (prefix) {
+        const afterPrefix = value.substring(prefix.length)
+        const tag = `<%#${prefix}`
+        const hasExtraWhitespace = afterPrefix.match(/^\s{2,}/) && !afterPrefix.startsWith("  \n") && !afterPrefix.startsWith("\n")
+
+        if (hasExtraWhitespace) {
+          this.reportWhitespace(node, openTag, closeTag, value, "start", prefix.length, `Remove extra whitespace after \`${tag}\`. This looks like a temporarily commented ERB tag.`, "after-comment-equals", "info")
+        } else {
+          this.addOffense(
+            `\`${tag}\` looks like a temporarily commented ERB tag.`,
+            openTag.location,
+            { node, openTag, closeTag, content: value, fixType: "after-comment-equals", unsafe: true },
+            "info"
+          )
+        }
       }
     }
 
@@ -39,6 +52,17 @@ class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor<ERBNoExtraWh
     }
   }
 
+  private getCommentedTagPrefix(content: string): string | null {
+    if (content.startsWith("graphql")) return "graphql"
+    if (content.startsWith("%=")) return "%="
+    if (content.startsWith("==")) return "=="
+    if (content.startsWith("%")) return "%"
+    if (content.startsWith("=")) return "="
+    if (content.startsWith("-")) return "-"
+
+    return null
+  }
+
   private hasExtraLeadingWhitespace(content: string): boolean {
     return content.startsWith("  ") && !content.startsWith("  \n")
   }
@@ -82,7 +106,9 @@ class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor<ERBNoExtraWh
     position: "start" | "end",
     offset: number,
     message: string,
-    fixType: "after-open" | "before-close" | "after-comment-equals"
+    fixType: "after-open" | "before-close" | "after-comment-equals",
+    severity?: LintSeverity,
+    unsafe?: boolean,
   ): void {
     const location = this.getWhitespaceLocation(node, content, position, offset)
     this.addOffense(message, location, {
@@ -90,14 +116,15 @@ class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor<ERBNoExtraWh
       openTag,
       closeTag,
       content,
-      fixType
-    })
+      fixType,
+      unsafe,
+    }, severity)
   }
 }
 
 export class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAutofixContext> {
   static autocorrectable = true
-  name = "erb-no-extra-whitespace-inside-tags"
+  static ruleName = "erb-no-extra-whitespace-inside-tags"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -107,7 +134,7 @@ export class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAut
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBNoExtraWhitespaceAutofixContext>[] {
-    const visitor = new ERBNoExtraWhitespaceInsideTagsVisitor(this.name, context)
+    const visitor = new ERBNoExtraWhitespaceInsideTagsVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 
@@ -131,13 +158,16 @@ export class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAut
         node.content.value = content.replace(/^\s{2,}/, " ")
         break
 
-      case "after-comment-equals":
-        if (content.startsWith("=")) {
-          const afterEquals = content.substring(1)
-          node.content.value = "= " + afterEquals.replace(/^\s{2,}/, "")
+      case "after-comment-equals": {
+        const prefix = content.startsWith("graphql") ? "graphql" : content.startsWith("%=") ? "%=" : content.startsWith("==") ? "==" : content.startsWith("%") ? "%" : content.startsWith("=") ? "=" : content.startsWith("-") ? "-" : null
+
+        if (prefix) {
+          const afterPrefix = content.substring(prefix.length)
+          node.content.value = prefix + " " + afterPrefix.replace(/^\s{2,}/, "")
         }
 
         break
+      }
       default:
         return null
     }

package/src/rules/erb-no-inline-case-conditions.ts

@@ -0,0 +1,54 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBCaseNode, ERBCaseMatchNode, ERBWhenNode, ERBInNode, ParseResult, ParserOptions } from "@herb-tools/core"
+
+class ERBNoInlineCaseConditionsVisitor extends BaseRuleVisitor {
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.checkConditions(node, "when")
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.checkConditions(node, "in")
+    this.visitChildNodes(node)
+  }
+
+  private checkConditions(node: ERBCaseNode | ERBCaseMatchNode, type: string): void {
+    if (!node.conditions || node.conditions.length === 0) return
+
+    for (const condition of node.conditions as (ERBWhenNode | ERBInNode)[]) {
+      if (condition.tag_opening === null) {
+        this.addOffense(
+          `A \`case\` statement with \`${type}\` conditions in a single ERB tag cannot be reliably parsed, compiled, and formatted. Use separate ERB tags for \`case\` and its conditions (e.g., \`<% case x %>\` followed by \`<% ${type} y %>\`).`,
+          node.location,
+        )
+        break
+      }
+    }
+  }
+}
+
+export class ERBNoInlineCaseConditionsRule extends ParserRule {
+  static ruleName = "erb-no-inline-case-conditions"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning",
+    }
+  }
+
+  get parserOptions(): Partial<ParserOptions> {
+    return { strict: false }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoInlineCaseConditionsVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-no-instance-variables-in-partials.ts

@@ -0,0 +1,101 @@
+import { PrismVisitor, PrismNodes } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+
+import { isPartialFile } from "./file-utils.js"
+import { locationFromOffset } from "./rule-utils.js"
+
+import type { ParseResult, ParserOptions, PrismLocation } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+interface InstanceVariableNode {
+  name: string
+  location: PrismLocation
+}
+
+type InstanceVariableUsage = "read" | "write"
+
+interface InstanceVariableReference {
+  name: string
+  usage: InstanceVariableUsage
+  startOffset: number
+  length: number
+}
+
+class InstanceVariableCollector extends PrismVisitor {
+  public readonly instanceVariables: InstanceVariableReference[] = []
+
+  visitInstanceVariableReadNode(node: PrismNodes.InstanceVariableReadNode): void {
+    this.collect(node, "read")
+  }
+
+  visitInstanceVariableWriteNode(node: PrismNodes.InstanceVariableWriteNode): void {
+    this.collect(node, "write")
+  }
+
+  visitInstanceVariableAndWriteNode(node: PrismNodes.InstanceVariableAndWriteNode): void {
+    this.collect(node, "write")
+  }
+
+  visitInstanceVariableOrWriteNode(node: PrismNodes.InstanceVariableOrWriteNode): void {
+    this.collect(node, "write")
+  }
+
+  visitInstanceVariableOperatorWriteNode(node: PrismNodes.InstanceVariableOperatorWriteNode): void {
+    this.collect(node, "write")
+  }
+
+  visitInstanceVariableTargetNode(node: PrismNodes.InstanceVariableTargetNode): void {
+    this.collect(node, "write")
+  }
+
+  private collect(node: InstanceVariableNode, usage: InstanceVariableUsage): void {
+    this.instanceVariables.push({
+      name: node.name,
+      usage,
+      startOffset: node.location.startOffset,
+      length: node.location.length
+    })
+  }
+}
+
+export class ERBNoInstanceVariablesInPartialsRule extends ParserRule {
+  static ruleName = "erb-no-instance-variables-in-partials"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+    }
+  }
+
+  get parserOptions(): Partial<ParserOptions> {
+    return {
+      track_whitespace: true,
+      prism_program: true,
+    }
+  }
+
+  isEnabled(_result: ParseResult, context?: Partial<LintContext>): boolean {
+    return isPartialFile(context?.fileName) === true
+  }
+
+  check(result: ParseResult, _context?: Partial<LintContext>): UnboundLintOffense[] {
+    const source = result.value.source
+    const prismNode = result.value.prismNode
+
+    if (!prismNode || !source) return []
+
+    const collector = new InstanceVariableCollector()
+
+    collector.visit(prismNode)
+
+    return collector.instanceVariables.map(ivar => {
+      const location = locationFromOffset(source, ivar.startOffset, ivar.length)
+      const message = ivar.usage === "read"
+        ? `Avoid using instance variables in partials. Pass \`${ivar.name}\` as a local variable instead.`
+        : `Avoid setting instance variables in partials. Use a local variable instead of \`${ivar.name}\`.`
+
+      return this.createOffense(message, location)
+    })
+  }
+}