// adjustedMemberSignature returns the member signature found on the given node, adjusted for
// the parent type's generics, as specified in this type reference. Will panic if the type reference
// does not refer to the node's parent type.
func (tr TypeReference) adjustedMemberSignature(node compilergraph.GraphNode) string {
compilerutil.DCHECK(func() bool {
return node.StartQuery().In(NodePredicateMember).GetNode() == tr.referredTypeNode()
}, "Type reference must be parent of member node")
// Retrieve the generics of the parent type.
parentNode := tr.referredTypeNode()
pgit := parentNode.StartQuery().Out(NodePredicateTypeGeneric).BuildNodeIterator()
// Parse the member signature.
esig := &proto.MemberSig{}
memberSig := node.GetTagged(NodePredicateMemberSignature, esig).(*proto.MemberSig)
// Replace the generics of the parent type in the signature with those of the type reference.
generics := tr.Generics()
var index = 0
var memberType = tr.Build(memberSig.GetMemberType()).(TypeReference)
for pgit.Next() {
genericNode := pgit.Node()
genericRef := generics[index]
genericType := TGTypeDecl{genericNode, tr.tdg}
// Replace the generic in the member type.
memberType = memberType.ReplaceType(genericType, genericRef)
// Replace the generic in any generic constraints.
for cindex, constraint := range memberSig.GetGenericConstraints() {
memberSig.GenericConstraints[cindex] = tr.Build(constraint).(TypeReference).
ReplaceType(genericType, genericRef).
Value()
}
index = index + 1
}
adjustedType := memberType.Value()
memberSig.MemberType = &adjustedType
return memberSig.Value()
}
// ResolutionPath returns the full resolution path for this type reference.
// Panics if this is not a RefKind of TypeRefPath.
func (t SRGTypeRef) ResolutionPath() string {
compilerutil.DCHECK(func() bool { return t.RefKind() == TypeRefPath }, "Expected type ref path")
var resolvePathPieces = make([]string, 0)
var currentPath compilergraph.GraphNode = t.GraphNode.
GetNode(parser.NodeTypeReferencePath).
GetNode(parser.NodeIdentifierPathRoot)
for {
// Add the path piece to the array.
name := currentPath.Get(parser.NodeIdentifierAccessName)
resolvePathPieces = append([]string{name}, resolvePathPieces...)
// If there is a source, continue searching.
source, found := currentPath.TryGetNode(parser.NodeIdentifierAccessSource)
if !found {
break
}
currentPath = source
}
return strings.Join(resolvePathPieces, ".")
}
// Parameters returns the parameters defined on this type ref.
// Panics if this is not a RefKind of TypeRefPath.
func (t SRGTypeRef) Parameters() []SRGTypeRef {
compilerutil.DCHECK(func() bool { return t.RefKind() == TypeRefPath }, "Expected type ref path")
return t.subReferences(parser.NodeTypeReferenceParameter)
}
// InnerReference returns the inner type reference, if this is a nullable or stream.
func (t SRGTypeRef) InnerReference() SRGTypeRef {
compilerutil.DCHECK(func() bool { return t.RefKind() != TypeRefPath }, "Expected non-path")
return SRGTypeRef{t.GraphNode.GetNode(parser.NodeTypeReferenceInnerType), t.srg}
}