[Selection input autocomplete] Don't compare constructor names to hardcoded string (#27951)

## Summary & Motivation
Turns out the auto-complete suggestions weren't working as expected due
to comparing constructor names which get minified in the built app. I
will research a better approach than this but for now comparing to the
name of the classes works.


## How I Tested These Changes

built the app and tested the auto-complete behavior

Author: salazarm

js_modules/dagster-ui/packages/ui-core/src/selection/BaseSelectionVisitor.ts

@@ -6,6 +6,11 @@ import {RuleNode} from 'antlr4ts/tree/RuleNode';
 import {
   ParenthesizedExpressionContext,
   PostAttributeValueWhitespaceContext,
+  PostExpressionWhitespaceContext,
+  PostLogicalOperatorWhitespaceContext,
+  PostNeighborTraversalWhitespaceContext,
+  PostNotOperatorWhitespaceContext,
+  PostUpwardTraversalWhitespaceContext,
 } from './generated/SelectionAutoCompleteParser';
 import {SelectionAutoCompleteVisitor as _SelectionAutoCompleteVisitor} from './generated/SelectionAutoCompleteVisitor';
 
@@ -79,10 +84,9 @@ export class BaseSelectionVisitor
       // If child's start..stop doesn't include the cursor, skip
       // (unless forced)
       if (child.start && child.stop) {
-        const isWhitespace = child.constructor.name.endsWith('WhitespaceContext');
         if (
           !this.nodeIncludesCursor(child) &&
-          (!isWhitespace || child.start.startIndex !== this.cursorIndex) &&
+          (!isWhitespaceContext(child) || child.start.startIndex !== this.cursorIndex) &&
           !this.forceVisitCtx.has(child)
         ) {
           continue;
@@ -91,7 +95,8 @@ export class BaseSelectionVisitor
         const nextChild = i + 1 < childCount ? (node.getChild(i + 1) as ParserRuleContext) : null;
         if (
           !this.nodeIncludesCursor(child, 0) &&
-          nextChild?.constructor.name.endsWith('WhitespaceContext') &&
+          nextChild &&
+          isWhitespaceContext(nextChild) &&
           !this.forceVisitCtx.has(child)
         ) {
           continue;
@@ -152,3 +157,17 @@ export class BaseSelectionVisitor
 
   public visitPostExpressionWhitespace(_ctx: any) {}
 }
+
+function isWhitespaceContext(ctx: ParserRuleContext) {
+  switch (ctx.constructor.name) {
+    case PostAttributeValueWhitespaceContext.name:
+    case PostExpressionWhitespaceContext.name:
+    case PostLogicalOperatorWhitespaceContext.name:
+    case PostNeighborTraversalWhitespaceContext.name:
+    case PostNotOperatorWhitespaceContext.name:
+    case PostUpwardTraversalWhitespaceContext.name:
+      return true;
+    default:
+      return false;
+  }
+}

js_modules/dagster-ui/packages/ui-core/src/selection/SelectionAutoCompleteVisitor.ts

@@ -180,7 +180,7 @@ export class SelectionAutoCompleteVisitor extends BaseSelectionVisitor {
     this.stopReplacementIndex = ctx.stop!.stopIndex + 1;
 
     const parentChildren = ctx.parent?.children ?? [];
-    if (parentChildren[0]?.constructor.name === 'AttributeNameContext') {
+    if (parentChildren[0]?.constructor.name === AttributeNameContext.name) {
       const rawValue = getValueNodeValue(ctx.value());
       this.addAttributeValueResults(parentChildren[0].text, rawValue);
     }
@@ -192,12 +192,12 @@ export class SelectionAutoCompleteVisitor extends BaseSelectionVisitor {
       let valueNode: ParserRuleContext | null = null;
 
       const parentChildren = ctx.parent?.children ?? [];
-      if (parentChildren[0]?.constructor.name === 'AttributeNameContext') {
+      if (parentChildren[0]?.constructor.name === AttributeNameContext.name) {
         attributeName = parentChildren[0] as ParserRuleContext;
       }
-      if (parentChildren[1]?.constructor.name === 'AttributeValueContext') {
+      if (parentChildren[1]?.constructor.name === AttributeValueContext.name) {
         valueNode = parentChildren[1] as ParserRuleContext;
-      } else if (parentChildren[2]?.constructor.name === 'AttributeValueContext') {
+      } else if (parentChildren[2]?.constructor.name === AttributeValueContext.name) {
         valueNode = parentChildren[2] as ParserRuleContext;
       }
 

js_modules/dagster-ui/packages/ui-core/src/selection/SelectionInputUtil.ts

@@ -1,6 +1,15 @@
 import {ParserRuleContext} from 'antlr4ts';
 
-import {AttributeValueContext} from './generated/SelectionAutoCompleteParser';
+import {
+  AttributeValueContext,
+  IncompleteLeftQuotedStringValueContext,
+  IncompleteRightQuotedStringValueContext,
+  QuotedStringValueContext,
+  UnclosedExpressionlessFunctionExpressionContext,
+  UnclosedFunctionExpressionContext,
+  UnclosedParenthesizedExpressionContext,
+  UnquotedStringValueContext,
+} from './generated/SelectionAutoCompleteParser';
 
 export const removeQuotesFromString = (value: string) => {
   if (value.length > 1 && value[0] === '"' && value[value.length - 1] === '"') {
@@ -11,28 +20,35 @@ export const removeQuotesFromString = (value: string) => {
 
 export function getValueNodeValue(ctx: ParserRuleContext | null) {
   switch (ctx?.constructor.name) {
-    case 'UnquotedStringValueContext':
+    case UnquotedStringValueContext.name:
       return ctx.text;
-    case 'IncompleteLeftQuotedStringValueContext':
+    case IncompleteLeftQuotedStringValueContext.name:
       return ctx.text.slice(1);
-    case 'IncompleteRightQuotedStringValueContext':
+    case IncompleteRightQuotedStringValueContext.name:
       return ctx.text.slice(0, -1);
-    case 'QuotedStringValueContext':
+    case QuotedStringValueContext.name:
       return ctx.text.slice(1, -1);
-    case 'AttributeValueContext':
+    case AttributeValueContext.name:
       return getValueNodeValue((ctx as AttributeValueContext).value());
     default:
       return ctx?.text ?? '';
   }
 }
 
-export function isInsideExpressionlessParenthesizedExpression(context: ParserRuleContext) {
-  if (context.parent) {
-    const nodeType = context.parent.constructor.name;
-    if (nodeType.startsWith('Unclosed')) {
-      return true;
+export function isInsideExpressionlessParenthesizedExpression(
+  context: ParserRuleContext | undefined,
+) {
+  const parent = context?.parent;
+  if (parent) {
+    const nodeType = parent.constructor.name;
+    switch (nodeType) {
+      case UnclosedParenthesizedExpressionContext.name:
+      case UnclosedFunctionExpressionContext.name:
+      case UnclosedExpressionlessFunctionExpressionContext.name:
+        return true;
+      default:
+        return isInsideExpressionlessParenthesizedExpression(parent);
     }
-    return isInsideExpressionlessParenthesizedExpression(context.parent);
   }
   return false;
 }