goscript 0.1.2 → 0.1.4

package/compiler/semantic-model.go

@@ -88,12 +88,21 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 	if diagnosticsHaveErrors(diagnostics) {
 		return model, diagnostics
 	}
+	anonymousInterfaceGraph, anonymousInterfaceDiagnostics := o.resolveAnonymousInterfaceImplementationGraph(ctx, model)
+	diagnostics = append(diagnostics, anonymousInterfaceDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		return model, diagnostics
+	}
 	for {
 		asyncCount := semanticAsyncFunctionCount(model)
 		diagnostics = append(diagnostics, o.applyInterfaceAsyncMethods(ctx, model, interfaceGraph)...)
 		if diagnosticsHaveErrors(diagnostics) {
 			return model, diagnostics
 		}
+		diagnostics = append(diagnostics, o.applyAnonymousInterfaceAsyncMethods(ctx, model, anonymousInterfaceGraph)...)
+		if diagnosticsHaveErrors(diagnostics) {
+			return model, diagnostics
+		}
 		diagnostics = append(diagnostics, o.propagateFunctionAsync(ctx, model)...)
 		if diagnosticsHaveErrors(diagnostics) {
 			return model, diagnostics
@@ -107,15 +116,18 @@ func (o *SemanticModelOwner) Build(ctx context.Context, graph *PackageGraph) (*S
 
 func newSemanticModel() *SemanticModel {
 	return &SemanticModel{
-		packages:             make(map[string]*semanticPackage),
-		addressTaken:         make(map[types.Object]bool),
-		needsVarRef:          make(map[types.Object]bool),
-		functions:            make(map[*types.Func]*semanticFunction),
-		functionsByFullName:  make(map[string]*semanticFunction),
-		functionLookupMisses: make(map[*types.Func]bool),
-		types:                make(map[*types.Named]*semanticType),
-		values:               make(map[types.Object]*semanticValue),
-		generatedImports:     make(map[string]map[string]bool),
+		packages:                 make(map[string]*semanticPackage),
+		addressTaken:             make(map[types.Object]bool),
+		needsVarRef:              make(map[types.Object]bool),
+		functions:                make(map[*types.Func]*semanticFunction),
+		functionsByFullName:      make(map[string]*semanticFunction),
+		functionLookupMisses:     make(map[*types.Func]bool),
+		functionFullNames:        make(map[*types.Func]string),
+		types:                    make(map[*types.Named]*semanticType),
+		values:                   make(map[types.Object]*semanticValue),
+		generatedImports:         make(map[string]map[string]bool),
+		asyncInterfaceMethods:    make(map[string]bool),
+		asyncInterfaceMethodObjs: make(map[*types.Func]bool),
 	}
 }
 
@@ -555,7 +567,7 @@ func (o *SemanticModelOwner) addFunction(
 			return existing
 		}
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if existing := model.functionsByFullName[fullName]; existing != nil {
 			model.functions[fn] = existing
 			if origin := fn.Origin(); origin != nil {
@@ -583,7 +595,7 @@ func (o *SemanticModelOwner) addFunction(
 	if origin := fn.Origin(); origin != nil {
 		model.functions[origin] = semFn
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if existing := model.functionsByFullName[fullName]; existing == nil {
 			model.functionsByFullName[fullName] = semFn
 		}
@@ -932,7 +944,7 @@ func semanticFunctionFor(model *SemanticModel, fn *types.Func) *semanticFunction
 			return semFn
 		}
 	}
-	if fullName := fn.FullName(); fullName != "" {
+	if fullName := model.functionFullName(fn); fullName != "" {
 		if semFn := model.functionsByFullName[fullName]; semFn != nil {
 			model.functions[fn] = semFn
 			return semFn
@@ -989,6 +1001,8 @@ func callUsesFunctionValue(pkg *packages.Package, expr ast.Expr) bool {
 	switch typed := expr.(type) {
 	case *ast.CallExpr:
 		return true
+	case *ast.TypeAssertExpr:
+		return true
 	case *ast.SelectorExpr:
 		selection := pkg.TypesInfo.Selections[typed]
 		if selection != nil {
@@ -1125,8 +1139,7 @@ func (o *SemanticModelOwner) propagateFunctionAsync(ctx context.Context, model *
 				return []Diagnostic{contextCanceledDiagnostic(err)}
 			}
 			for called := range semFn.calls {
-				calledFn := semanticFunctionFor(model, called)
-				if calledFn != nil && calledFn.async {
+				if model.functionAsync(called) {
 					if markFunctionAsync(semFn, "call:"+called.FullName()) {
 						changed = true
 					}
@@ -1167,17 +1180,15 @@ func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 	ctx context.Context,
 	model *SemanticModel,
 ) ([]semanticInterfaceImplementationGraphEntry, []Diagnostic) {
-	var interfaces []*types.Named
+	interfaces := collectInterfaceImplementationCandidates(model)
 	var concretes []*types.Named
 	for named, semType := range model.types {
 		if err := ctx.Err(); err != nil {
 			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
 		}
-		if semType.isInterface {
-			interfaces = append(interfaces, named)
-			continue
+		if !semType.isInterface {
+			concretes = append(concretes, namedOriginOrSelf(named))
 		}
-		concretes = append(concretes, named)
 	}
 	sortNamedTypes(interfaces)
 	sortNamedTypes(concretes)
@@ -1209,6 +1220,338 @@ func (o *SemanticModelOwner) resolveInterfaceImplementationGraph(
 	return implementationGraph, nil
 }
 
+func (o *SemanticModelOwner) resolveAnonymousInterfaceImplementationGraph(
+	ctx context.Context,
+	model *SemanticModel,
+) ([]semanticAnonymousInterfaceImplementation, []Diagnostic) {
+	interfaces := collectAnonymousInterfaceImplementationCandidates(model)
+	var concretes []*types.Named
+	for named, semType := range model.types {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		if !semType.isInterface {
+			concretes = append(concretes, namedOriginOrSelf(named))
+		}
+	}
+	methodSets := implementationMethodSets(concretes)
+	for _, namedIface := range collectNamedInterfaceImplementationCandidates(model) {
+		methodSets = append(methodSets, semanticImplementationMethodSet{
+			typ:      namedIface,
+			receiver: namedIface,
+			methods:  methodSetMap(namedIface),
+		})
+	}
+
+	implementationGraph := make([]semanticAnonymousInterfaceImplementation, 0)
+	for _, iface := range interfaces {
+		if err := ctx.Err(); err != nil {
+			return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		iface.Complete()
+		ifaceMethods := interfaceMethodMap(iface)
+		if len(ifaceMethods) == 0 {
+			continue
+		}
+		for _, methodSet := range methodSets {
+			if err := ctx.Err(); err != nil {
+				return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+			}
+			if !implementationHasMethods(methodSet.methods, ifaceMethods) {
+				continue
+			}
+			receiver := methodSet.receiver
+			if (methodSet.typ.TypeArgs() == nil || methodSet.typ.TypeArgs().Len() == 0) &&
+				methodSet.typ.TypeParams() != nil && methodSet.typ.TypeParams().Len() != 0 {
+				args := typeParamTypes(methodSet.typ.TypeParams())
+				if instantiated, err := types.Instantiate(nil, methodSet.typ, args, false); err == nil {
+					receiver = instantiated
+					if methodSet.pointer {
+						receiver = types.NewPointer(instantiated)
+					}
+				}
+			}
+			if !types.Implements(receiver, iface) {
+				continue
+			}
+			implementationGraph = append(implementationGraph, semanticAnonymousInterfaceImplementation{
+				ifaceMethods: ifaceMethods,
+				implMethods:  implementationMethodMap(methodSet.methods, ifaceMethods),
+			})
+		}
+	}
+	return implementationGraph, nil
+}
+
+func collectInterfaceImplementationCandidates(model *SemanticModel) []*types.Named {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[string]bool)
+	var interfaces []*types.Named
+	add := func(named *types.Named) {
+		if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+			return
+		}
+		named = namedOriginOrSelf(named)
+		if _, ok := types.Unalias(named.Underlying()).(*types.Interface); !ok {
+			return
+		}
+		key := named.Obj().Pkg().Path() + "." + named.Obj().Name()
+		if seen[key] {
+			return
+		}
+		seen[key] = true
+		interfaces = append(interfaces, named)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			add(typed)
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectAnonymousInterfaceImplementationCandidates(model *SemanticModel) []*types.Interface {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[*types.Interface]bool)
+	var interfaces []*types.Interface
+	add := func(iface *types.Interface) {
+		if iface == nil || seen[iface] {
+			return
+		}
+		seen[iface] = true
+		interfaces = append(interfaces, iface)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			add(typed)
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectNamedInterfaceImplementationCandidates(model *SemanticModel) []*types.Named {
+	if model == nil {
+		return nil
+	}
+	seen := make(map[string]bool)
+	var interfaces []*types.Named
+	add := func(named *types.Named) {
+		if named == nil {
+			return
+		}
+		if _, ok := types.Unalias(named.Underlying()).(*types.Interface); !ok {
+			return
+		}
+		key := types.TypeString(named, func(pkg *types.Package) string {
+			if pkg == nil {
+				return ""
+			}
+			return pkg.Path()
+		})
+		if seen[key] {
+			return
+		}
+		seen[key] = true
+		interfaces = append(interfaces, named)
+	}
+	var collect func(types.Type)
+	seenTypes := make(map[types.Type]bool)
+	collect = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		typ = types.Unalias(typ)
+		if seenTypes[typ] {
+			return
+		}
+		seenTypes[typ] = true
+		switch typed := typ.(type) {
+		case *types.Named:
+			add(typed)
+			collect(typed.Underlying())
+		case *types.Pointer:
+			collect(typed.Elem())
+		case *types.Slice:
+			collect(typed.Elem())
+		case *types.Array:
+			collect(typed.Elem())
+		case *types.Map:
+			collect(typed.Key())
+			collect(typed.Elem())
+		case *types.Chan:
+			collect(typed.Elem())
+		case *types.Struct:
+			for field := range typed.Fields() {
+				collect(field.Type())
+			}
+		case *types.Interface:
+			typed.Complete()
+			for method := range typed.Methods() {
+				collect(method.Type())
+			}
+		case *types.Signature:
+			if typed.Recv() != nil {
+				collect(typed.Recv().Type())
+			}
+			collectTuple(collect, typed.Params())
+			collectTuple(collect, typed.Results())
+		}
+	}
+	for _, semType := range model.types {
+		collect(semType.named)
+		for _, field := range semType.fields {
+			collect(field.typ)
+		}
+	}
+	for _, semFn := range model.functions {
+		collect(semFn.signature)
+	}
+	for _, semValue := range model.values {
+		collect(semValue.typ)
+	}
+	for _, semPkg := range model.packages {
+		for _, assertion := range semPkg.typeAssertions {
+			collect(assertion.source)
+			collect(assertion.target)
+		}
+		for _, fact := range semPkg.nilFacts {
+			collect(fact.typ)
+		}
+	}
+	return interfaces
+}
+
+func collectTuple(collect func(types.Type), tuple *types.Tuple) {
+	if tuple == nil {
+		return
+	}
+	for v := range tuple.Variables() {
+		collect(v.Type())
+	}
+}
+
 func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 	ctx context.Context,
 	model *SemanticModel,
@@ -1226,10 +1569,11 @@ func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 			asyncMethods: make(map[string]bool),
 		}
 		for methodName, implMethod := range graphEntry.implMethods {
-			implFn := model.functions[implMethod]
+			implFn := semanticFunctionFor(model, implMethod)
 			if implFn != nil && implFn.async {
 				implementation.asyncMethods[methodName] = true
-				if ifaceFn := model.functions[graphEntry.ifaceMethods[methodName]]; ifaceFn != nil {
+				model.markInterfaceMethodAsync(graphEntry.ifaceMethods[methodName])
+				if ifaceFn := semanticFunctionFor(model, graphEntry.ifaceMethods[methodName]); ifaceFn != nil {
 					markFunctionAsync(ifaceFn, "interface-implementation")
 				}
 			}
@@ -1238,13 +1582,61 @@ func (o *SemanticModelOwner) applyInterfaceAsyncMethods(
 			if !async {
 				continue
 			}
-			markFunctionAsync(model.functions[graphEntry.implMethods[methodName]], "interface-method")
+			markFunctionAsync(semanticFunctionFor(model, graphEntry.implMethods[methodName]), "interface-method")
 		}
 		model.interfaceImplementations = append(model.interfaceImplementations, implementation)
 	}
 	return nil
 }
 
+func (o *SemanticModelOwner) applyAnonymousInterfaceAsyncMethods(
+	ctx context.Context,
+	model *SemanticModel,
+	interfaceGraph []semanticAnonymousInterfaceImplementation,
+) []Diagnostic {
+	for _, graphEntry := range interfaceGraph {
+		if err := ctx.Err(); err != nil {
+			return []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		for methodName, implMethod := range graphEntry.implMethods {
+			if model.functionAsync(implMethod) {
+				model.markInterfaceMethodAsync(graphEntry.ifaceMethods[methodName])
+			}
+		}
+	}
+	return nil
+}
+
+func (m *SemanticModel) functionAsync(fn *types.Func) bool {
+	semFn := semanticFunctionFor(m, fn)
+	if semFn != nil && semFn.async {
+		return true
+	}
+	return m.interfaceMethodAsync(fn)
+}
+
+func (m *SemanticModel) markInterfaceMethodAsync(fn *types.Func) {
+	if m == nil || fn == nil {
+		return
+	}
+	m.asyncInterfaceMethodObjs[fn] = true
+	key := m.functionFullName(fn)
+	if key != "" {
+		m.asyncInterfaceMethods[key] = true
+	}
+}
+
+func (m *SemanticModel) interfaceMethodAsync(fn *types.Func) bool {
+	if m == nil || fn == nil {
+		return false
+	}
+	if m.asyncInterfaceMethodObjs[fn] {
+		return true
+	}
+	key := m.functionFullName(fn)
+	return key != "" && m.asyncInterfaceMethods[key]
+}
+
 func contextCanceledDiagnostic(err error) Diagnostic {
 	return Diagnostic{
 		Severity: DiagnosticSeverityError,
@@ -1304,6 +1696,29 @@ func interfaceMethodMap(iface *types.Interface) map[string]*types.Func {
 	return methods
 }
 
+func (m *SemanticModel) functionFullName(fn *types.Func) string {
+	if m == nil || fn == nil {
+		return ""
+	}
+	original := fn
+	if fullName, ok := m.functionFullNames[original]; ok {
+		return fullName
+	}
+	if origin := fn.Origin(); origin != nil && origin != fn {
+		if fullName, ok := m.functionFullNames[origin]; ok {
+			m.functionFullNames[original] = fullName
+			return fullName
+		}
+		fn = origin
+	}
+	fullName := fn.FullName()
+	m.functionFullNames[fn] = fullName
+	if original != fn {
+		m.functionFullNames[original] = fullName
+	}
+	return fullName
+}
+
 func implementationMethodSets(concretes []*types.Named) []semanticImplementationMethodSet {
 	methodSets := make([]semanticImplementationMethodSet, 0, len(concretes)*2)
 	for _, concrete := range concretes {
@@ -1378,6 +1793,16 @@ func typeParamTypes(params *types.TypeParamList) []types.Type {
 	return args
 }
 
+func namedOriginOrSelf(named *types.Named) *types.Named {
+	if named == nil {
+		return nil
+	}
+	if origin := named.Origin(); origin != nil {
+		return origin
+	}
+	return named
+}
+
 func sortNamedTypes(named []*types.Named) {
 	slices.SortFunc(named, func(a, b *types.Named) int {
 		return cmp.Compare(namedTypeKey(a), namedTypeKey(b))