Visible intersection types handling (#13266)

Closes #13042

- Methods of “visible” intersection type are now visible in CB (without type casting inserted)
- Refactoring of CB filtering and managing of types in general


https://github.com/user-attachments/assets/e78d2477-5af7-4c76-a9c0-9ebca6eb82d0

Author: vitvakatu

CHANGELOG.md

@@ -18,6 +18,8 @@
 - [Add keyboard shortcuts for formatting documentation][13134]
 - [New right-side panel][13135], unified between tabs.
 - [Allow selecting expected types for arguments of grouped components.][13161]
+- [Methods for ‘intersection’ types are now visible in Component
+  Browser.][13266]
 - [Allow marking grouped component arguments as required or providing a default
   value.][13254]
 
@@ -35,6 +37,7 @@
 [13134]: https://github.com/enso-org/enso/pull/13134
 [13135]: https://github.com/enso-org/enso/pull/13135
 [13161]: https://github.com/enso-org/enso/pull/13161
+[13266]: https://github.com/enso-org/enso/pull/13266
 [13254]: https://github.com/enso-org/enso/pull/13254
 
 #### Enso Standard Library

app/gui/src/project-view/components/CodeEditor/CodeEditorTooltip.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import { injectCurrentProject } from '$/components/WithCurrentProject.vue'
 import { type NodeId } from '@/stores/graph'
 import { type GraphDb } from '@/stores/graph/graphDatabase'
 import { type SuggestionDbStore } from '@/stores/suggestionDatabase'
@@ -11,16 +12,24 @@ const { nodeId, syntax, graphDb, suggestionDbStore } = defineProps<{
   suggestionDbStore: SuggestionDbStore
 }>()
 
+const { names: projectNames } = injectCurrentProject().storesRefs
+
 const expressionInfo = computed(() => nodeId && graphDb.getExpressionInfo(nodeId))
-const typeName = computed(
-  () => expressionInfo.value && (expressionInfo.value.typename ?? 'Unknown'),
-)
+const typeName = computed(() => {
+  const type = expressionInfo.value?.typeInfo?.primaryType
+  if (type == null || projectNames.value == null) return 'Unknown'
+  return projectNames.value.printProjectPath(type)
+})
 const executionTimeMs = computed(
   () =>
     expressionInfo.value?.profilingInfo[0] &&
     (expressionInfo.value.profilingInfo[0].ExecutionTime.nanoTime / 1_000_000).toFixed(3),
 )
 const method = computed(() => expressionInfo.value?.methodCall?.methodPointer)
+const methodPath = computed(() => {
+  if (method.value == null || projectNames.value == null) return 'Unknown'
+  return projectNames.value.printProjectPath(method.value.definedOnType) + '.' + method.value.name
+})
 const group = computed(() => {
   const id = method.value && suggestionDbStore.entries.findByMethodPointer(method.value)
   if (id == null) return
@@ -42,6 +51,6 @@ const group = computed(() => {
   <div v-if="typeName">Type: {{ typeName }}</div>
   <div v-if="executionTimeMs != null">Execution Time: {{ executionTimeMs }}ms</div>
   <div>Syntax: {{ syntax }}</div>
-  <div v-if="method">Method: {{ method.module }}.{{ method.name }}</div>
+  <div v-if="methodPath">Method: {{ methodPath }}</div>
   <div v-if="group" :style="{ color: group.color }">Group: {{ group.name }}</div>
 </template>

app/gui/src/project-view/components/ComponentBrowser.vue

@@ -25,6 +25,7 @@ import { tryGetIndex } from '@/util/data/array'
 import type { Opt } from '@/util/data/opt'
 import { Rect } from '@/util/data/rect'
 import { Vec2 } from '@/util/data/vec2'
+import { parseAbsoluteProjectPathRaw } from '@/util/projectPath'
 import { debouncedGetter } from '@/util/reactivity'
 import type { ComponentInstance } from 'vue'
 import { computed, onMounted, onUnmounted, ref, toValue, watch, watchEffect } from 'vue'
@@ -247,7 +248,11 @@ const previewedSuggestionReturnType = computed(() => {
     appliedEntry ? appliedEntry
     : props.usage.type === 'editNode' ? graphStore.db.getNodeMainSuggestion(props.usage.node)
     : undefined
-  return entry?.returnType(projectNames)
+  const returnType = entry?.returnType(projectNames)
+  if (returnType == null) return undefined
+  const parsed = parseAbsoluteProjectPathRaw(returnType)
+  if (parsed.ok) return parsed.value
+  return undefined
 })
 
 const previewDataSource = computed<VisualizationDataSource | undefined>(() => {

app/gui/src/project-view/components/ComponentBrowser/ComponentEditorLabel.vue

@@ -13,7 +13,7 @@ type DisplayedAdditionalTypes =
 
 const additionalTypes = computed<DisplayedAdditionalTypes>(() => {
   if (props.selfArg?.type === 'known') {
-    const additionalTypes = props.selfArg.additionalTypes.flatMap((type) =>
+    const additionalTypes = props.selfArg.typeInfo?.hiddenTypes.flatMap((type) =>
       type.path ? qnLastSegment(type.path) : [],
     )
     if (additionalTypes.length === 0) return null
@@ -28,8 +28,8 @@ const additionalTypes = computed<DisplayedAdditionalTypes>(() => {
 
 const label = computed(() => {
   if (props.selfArg == null) return 'Input'
-  if (props.selfArg.type === 'known' && props.selfArg.typename.path) {
-    return qnLastSegment(props.selfArg.typename.path)
+  if (props.selfArg.type === 'known' && props.selfArg.typeInfo?.primaryType.path) {
+    return qnLastSegment(props.selfArg.typeInfo.primaryType.path)
   }
 
   return undefined

app/gui/src/project-view/components/ComponentBrowser/__tests__/component.test.ts

@@ -6,6 +6,7 @@ import {
   type MatchedSuggestion,
 } from '@/components/ComponentBrowser/component'
 import { Filtering } from '@/components/ComponentBrowser/filtering'
+import { TypeInfo } from '@/stores/project/computedValueRegistry'
 import {
   makeConstructor,
   makeMethod,
@@ -14,7 +15,7 @@ import {
   makeStaticMethod,
 } from '@/stores/suggestionDatabase/mockSuggestion'
 import { allRanges } from '@/util/data/range'
-import { ProjectPath } from '@/util/projectPath'
+import { ProjectPath, stdPath } from '@/util/projectPath'
 import { QualifiedName } from '@/util/qualifiedName'
 import shuffleSeed from 'shuffle-seed'
 import { expect, test } from 'vitest'
@@ -137,13 +138,15 @@ test.each`
   'Matched ranges of $highlighted with additional type are correct',
   ({ name, aliases, highlighted }) => {
     const pattern = 'foo_bar'
-    const entry = makeMethod(`local.Mock_Project.${name}`, { aliases: aliases ?? [] })
+    const entry = makeMethod(`Standard.Base.${name}`, { aliases: aliases ?? [] })
     const filtering = new Filtering({
       pattern,
       selfArg: {
         type: 'known',
-        typename: ProjectPath.create(undefined, 'Column' as QualifiedName),
-        additionalTypes: [ProjectPath.create(undefined, 'Table' as QualifiedName)],
+        typeInfo: TypeInfo.fromParsedTypes(
+          [stdPath('Standard.Base.Column')],
+          [stdPath('Standard.Base.Table')],
+        )!,
         ancestors: [],
       },
     })

app/gui/src/project-view/components/ComponentBrowser/__tests__/filtering.test.ts

@@ -1,4 +1,5 @@
 import { Filtering, type MatchResult } from '@/components/ComponentBrowser/filtering'
+import { TypeInfo } from '@/stores/project/computedValueRegistry'
 import { type SuggestionEntry } from '@/stores/suggestionDatabase/entry'
 import {
   makeConstructor,
@@ -9,12 +10,10 @@ import {
   makeModuleMethod,
   makeStaticMethod,
 } from '@/stores/suggestionDatabase/mockSuggestion'
-import { assert } from '@/util/assert'
-import { parseAbsoluteProjectPathRaw } from '@/util/projectPath'
+import { stdPath } from '@/util/projectPath'
 import { qnLastSegment } from '@/util/qualifiedName'
 import { expect, test } from 'vitest'
 import { type Opt } from 'ydoc-shared/util/data/opt'
-import { unwrap } from 'ydoc-shared/util/data/result'
 
 test.each([
   makeModuleMethod('Standard.Base.Data.read', { group: 'Standard.Base.MockGroup1' }),
@@ -40,24 +39,32 @@ test.each([
   expect(filtering.filter(entry)).toBeNull()
 })
 
-function stdPath(path: string) {
-  assert(path.startsWith('Standard.'))
-  return unwrap(parseAbsoluteProjectPathRaw(path))
-}
+test.each`
+  visibleTypes                                                        | entry1Matched | entry2Matched
+  ${['Standard.Base.Data.Table']}                                     | ${false}      | ${true}
+  ${['Standard.Base.Data.Vector.Vector']}                             | ${true}       | ${false}
+  ${['Standard.Base.Data.Vector.Vector', 'Standard.Base.Data.Table']} | ${true}       | ${true}
+  ${['Standard.Base.Data.Table', 'Standard.Base.Data.Vector.Vector']} | ${true}       | ${true}
+`(
+  `Visible types are taken into account when filtering: $visibleTypes`,
+  ({ visibleTypes, entry1Matched, entry2Matched }) => {
+    const entry1 = makeMethod('Standard.Base.Data.Vector.Vector.get')
+    const entry2 = makeMethod('Standard.Base.Data.Table.get')
+    const filtering = new Filtering({
+      selfArg: {
+        type: 'known',
+        typeInfo: TypeInfo.fromParsedTypes(visibleTypes.map(stdPath), [])!,
+        ancestors: [],
+      },
+    })
+    expect(filtering.filter(entry1)).toEqual(entry1Matched ? { score: 0 } : null)
+    expect(filtering.filter(entry2)).toEqual(entry2Matched ? { score: 0 } : null)
+  },
+)
 
-test('An Instance method is shown when self arg matches', () => {
+test('Filtering methods with no self type information', () => {
   const entry1 = makeMethod('Standard.Base.Data.Vector.Vector.get')
   const entry2 = makeMethod('Standard.Base.Data.Table.get')
-  const filteringWithSelfType = new Filtering({
-    selfArg: {
-      type: 'known',
-      typename: stdPath('Standard.Base.Data.Vector.Vector'),
-      additionalTypes: [],
-      ancestors: [],
-    },
-  })
-  expect(filteringWithSelfType.filter(entry1)).not.toBeNull()
-  expect(filteringWithSelfType.filter(entry2)).toBeNull()
   const filteringWithAnySelfType = new Filtering({
     selfArg: { type: 'unknown' },
   })
@@ -74,8 +81,7 @@ test('`Any` type methods taken into account when filtering', () => {
   const filtering = new Filtering({
     selfArg: {
       type: 'known',
-      typename: stdPath('Standard.Base.Data.Vector.Vector'),
-      additionalTypes: [],
+      typeInfo: TypeInfo.fromParsedTypes([stdPath('Standard.Base.Data.Vector.Vector')], [])!,
       ancestors: [],
     },
   })
@@ -87,20 +93,25 @@ test('`Any` type methods taken into account when filtering', () => {
   expect(filteringWithoutSelfType.filter(entry2)).toBeNull()
 })
 
-test('Additional self types and ancestors are taken into account when filtering', () => {
+test('Hidden self types and ancestors are taken into account when filtering', () => {
   const entry1 = makeMethod('Standard.Base.Data.Numbers.Float.abs')
   const entry2 = makeMethod('Standard.Base.Data.Numbers.Number.sqrt')
-  const additionalSelfType = stdPath('Standard.Base.Data.Numbers.Number')
-  const filteringWithAdditionalSelfType = new Filtering({
+  const hiddenSelfType = 'Standard.Base.Data.Numbers.Number'
+  const filteringWithHiddenSelfType = new Filtering({
     selfArg: {
       type: 'known',
-      typename: stdPath('Standard.Base.Data.Numbers.Float'),
-      additionalTypes: [additionalSelfType],
+      typeInfo: TypeInfo.fromParsedTypes(
+        [stdPath('Standard.Base.Data.Numbers.Float')],
+        [stdPath(hiddenSelfType)],
+      )!,
       ancestors: [],
     },
   })
-  expect(filteringWithAdditionalSelfType.filter(entry1)).not.toBeNull()
-  expect(filteringWithAdditionalSelfType.filter(entry2)).not.toBeNull()
+  expect(filteringWithHiddenSelfType.filter(entry1)).toEqual({ score: 0 })
+  expect(filteringWithHiddenSelfType.filter(entry2)).toEqual({
+    score: 1,
+    fromType: stdPath(hiddenSelfType),
+  })
 
   const filteringWithoutSelfType = new Filtering({})
   expect(filteringWithoutSelfType.filter(entry1)).toBeNull()
@@ -109,13 +120,15 @@ test('Additional self types and ancestors are taken into account when filtering'
   const filteringWithAncestors = new Filtering({
     selfArg: {
       type: 'known',
-      typename: stdPath('Standard.Base.Data.Numbers.Float'),
-      additionalTypes: [],
-      ancestors: [additionalSelfType],
+      typeInfo: TypeInfo.fromParsedTypes([stdPath('Standard.Base.Data.Numbers.Float')], [])!,
+      ancestors: [stdPath(hiddenSelfType)],
     },
   })
-  expect(filteringWithAncestors.filter(entry1)).not.toBeNull()
-  expect(filteringWithAncestors.filter(entry2)).not.toBeNull()
+  expect(filteringWithAncestors.filter(entry1)).toEqual({ score: 0 })
+  expect(filteringWithAncestors.filter(entry2)).toEqual({
+    score: 1,
+    fromType: undefined,
+  })
 })
 
 test.each([
@@ -130,8 +143,7 @@ test.each([
   const filtering = new Filtering({
     selfArg: {
       type: 'known',
-      typename: stdPath('Standard.Base.Data.Vector.Vector'),
-      additionalTypes: [],
+      typeInfo: TypeInfo.fromParsedTypes([stdPath('Standard.Base.Data.Vector.Vector')], [])!,
       ancestors: [],
     },
   })

app/gui/src/project-view/components/ComponentBrowser/__tests__/input.test.ts

@@ -1,10 +1,9 @@
 import { useComponentBrowserInput } from '@/components/ComponentBrowser/input'
 import { GraphDb, NodeId } from '@/stores/graph/graphDatabase'
-import { ComputedValueRegistry } from '@/stores/project/computedValueRegistry'
+import { ComputedValueRegistry, TypeInfo } from '@/stores/project/computedValueRegistry'
 import { SuggestionDb } from '@/stores/suggestionDatabase'
 import { makeMethod, makeType } from '@/stores/suggestionDatabase/mockSuggestion'
-import { unwrap } from '@/util/data/result'
-import { parseAbsoluteProjectPathRaw } from '@/util/projectPath'
+import { stdPath } from '@/util/projectPath'
 import { expect, test } from 'vitest'
 import { assert, assertUnreachable } from 'ydoc-shared/util/assert'
 import { Range } from 'ydoc-shared/util/data/range'
@@ -16,12 +15,10 @@ const operator2Id = '5eb16101-dd2b-4034-a6e2-476e8bfa1f2b' as NodeId
 function mockGraphDb() {
   const computedValueRegistryMock = ComputedValueRegistry.Mock()
   computedValueRegistryMock.db.set(operator1Id, {
-    typename: unwrap(parseAbsoluteProjectPathRaw('Standard.Base.Number')),
-    rawTypename: 'Standard.Base.Number',
+    typeInfo: TypeInfo.fromParsedTypes([stdPath('Standard.Base.Number')], [])!,
     methodCall: undefined,
     payload: { type: 'Value' },
     profilingInfo: [],
-    hiddenTypes: [],
     evaluationId: 1,
   })
   const db = GraphDb.Mock(computedValueRegistryMock)

app/gui/src/project-view/components/ComponentBrowser/filtering.ts

@@ -1,3 +1,4 @@
+import { TypeInfo } from '@/stores/project/computedValueRegistry'
 import { SuggestionKind, type SuggestionEntry } from '@/stores/suggestionDatabase/entry'
 import { ANY_TYPE } from '@/util/ensoTypes'
 import { type ProjectPath } from '@/util/projectPath'
@@ -8,12 +9,8 @@ import { Range } from 'ydoc-shared/util/data/range'
 export type SelfArg =
   | {
       type: 'known'
-      /** Type of the self argument. */
-      typename: ProjectPath
-      /** Ancestors of the type of the self argument. Does not include `Any` type. */
+      typeInfo: TypeInfo
       ancestors: ProjectPath[]
-      /** Additional (or ‘hidden’) types of the self argument. E.g. `Column` for single-column table.*/
-      additionalTypes: ProjectPath[]
     }
   | { type: 'unknown' }
 
@@ -282,13 +279,14 @@ export class Filtering {
     if (entry.kind !== SuggestionKind.Method || entry.selfType == null) return null
     if (this.selfArg.type !== 'known') return exactMatch()
     const entrySelfType = entry.selfType
-    if (entrySelfType.equals(this.selfArg.typename)) return exactMatch()
-    const { additionalTypes, ancestors } = this.selfArg
-    const additionalType = additionalTypes.find((t) => entrySelfType.equals(t))
-    const matchedAncestor = ancestors.find((t) => entrySelfType.equals(t))
-    if (entrySelfType.equals(ANY_TYPE) || additionalType != null || matchedAncestor != null)
-      // Matched ancestor are not added to `fromType`.
-      return { score: DIFFERENT_TYPE_PENALTY, fromType: additionalType }
+    const visibleTypes = this.selfArg.typeInfo.visibleTypes
+    const visibleTypeMatch = visibleTypes?.find((ty) => entrySelfType.equals(ty))
+    if (visibleTypeMatch != null) return exactMatch()
+    const hiddenTypeMatch = this.selfArg.typeInfo?.hiddenTypes.find((t) => entrySelfType.equals(t))
+    const matchedAncestor = this.selfArg.ancestors.find((t) => entrySelfType.equals(t))
+    if (entrySelfType.equals(ANY_TYPE) || hiddenTypeMatch != null || matchedAncestor != null)
+      // Matched ancestor are not added to `fromType`, because type casting is not needed.
+      return { score: DIFFERENT_TYPE_PENALTY, fromType: hiddenTypeMatch }
     return null
   }
 
@@ -322,7 +320,8 @@ export class Filtering {
     const selfTypeMatch = this.selfTypeMatches(entry)
     if (selfTypeMatch == null) return null
     if (this.pattern) {
-      const additionalSelfTypes = this.selfArg?.type === 'known' ? this.selfArg.additionalTypes : []
+      const additionalSelfTypes =
+        this.selfArg?.type === 'known' ? this.selfArg.typeInfo.hiddenTypes : []
       const patternMatch = this.pattern.tryMatch(
         entry.name,
         entry.aliasesAndMacros,

app/gui/src/project-view/components/ComponentBrowser/input.ts

@@ -140,15 +140,9 @@ export function useComponentBrowserInput(
     const definition = graphDb.getIdentDefiningNode(sourceNodeIdentifier.value)
     if (definition == null) return null
     const info = graphDb.getExpressionInfo(definition)
-    if (info == null) return { type: 'unknown' }
-    const { typename, hiddenTypes } = info
-    const additionalTypes = [...hiddenTypes]
-    const ancestors = []
-    if (typename != null) {
-      const entry = suggestionDb.getEntryByProjectPath(typename)
-      if (entry) ancestors.push(...suggestionDb.ancestors(entry))
-    }
-    return typename ? { type: 'known', typename, additionalTypes, ancestors } : { type: 'unknown' }
+    if (info == null || info.typeInfo == null) return { type: 'unknown' }
+    const ancestors = [...info.typeInfo.ancestors(suggestionDb)]
+    return { type: 'known', typeInfo: info.typeInfo, ancestors }
   })
 
   /** Apply given suggested entry to the input. */
@@ -183,7 +177,7 @@ export function useComponentBrowserInput(
     requiredImport: ProjectPath | undefined
   } {
     if (sourceNodeIdentifier.value && sourceNodeType.value?.type === 'known') {
-      const sourceType = sourceNodeType.value.typename
+      const sourceType = sourceNodeType.value.typeInfo.primaryType
       if (
         entryHasOwner(entry) &&
         !sourceType.equals(entry.memberOf) &&

app/gui/src/project-view/components/GraphEditor/GraphNode.vue

@@ -185,7 +185,7 @@ const {
   nodeRect,
   scale,
   isFocused: isOnlyOneSelected,
-  typename: () => expressionInfo.value?.rawTypename,
+  typename: () => expressionInfo.value?.typeInfo?.primaryType,
   dataSource: () => ({ type: 'node', nodeId: props.node.rootExpr.externalId }) as const,
   emit,
 })