Method typeToStringEx

internal/checker/printer.go:189–248

(t *Type, enclosingDeclaration *ast.Node, flags TypeFormatFlags, vc *VerbosityContext)

}

func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags TypeFormatFlags, vc *VerbosityContext) string {
	// Serialization of types can lead to (lazy) resolution of members, which can cause diagnostics that again require
	// serialization of types. This can potentially result in infinite recursion and stack overflows. To prevent that,
	// after a certain number of recursive invocations the function simply returns "?".
	if c.serializationLevel >= maxSerializationLevel {
		return "?"
	}
	newLine := ""
	if flags&TypeFormatFlagsMultilineObjectLiterals != 0 {
		newLine = "\n"
	}
	writer := printer.NewTextWriter(newLine, 0)
	noTruncation := ((vc == nil || vc.MaxTruncationLength == 0) && c.compilerOptions.NoErrorTruncation == core.TSTrue) || (flags&TypeFormatFlagsNoTruncation != 0)
	combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors
	if noTruncation {
		combinedFlags = combinedFlags | nodebuilder.FlagsNoTruncation
	}
	nodeBuilder, release := c.getNodeBuilder()
	defer release()
	oldVerbosity := nodeBuilder.verbosity
	nodeBuilder.verbosity = vc
	defer func() {
		nodeBuilder.verbosity = oldVerbosity
	}()
	c.serializationLevel++
	typeNode := nodeBuilder.TypeToTypeNode(t, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil)
	c.serializationLevel--
	if typeNode == nil {
		panic("should always get typenode")
	}
	// The unresolved type gets a synthesized comment on `any` to hint to users that it's not a plain `any`.
	// Otherwise, we always strip comments out.
	var p *printer.Printer
	if t == c.unresolvedType {
		p = createPrinterWithDefaults(nodeBuilder.EmitContext())
	} else {
		p = createPrinterWithRemoveComments(nodeBuilder.EmitContext())
	}
	var sourceFile *ast.SourceFile
	if enclosingDeclaration != nil {
		sourceFile = ast.GetSourceFileOfNode(enclosingDeclaration)
	}
	p.Write(typeNode, sourceFile, writer, nil)
	result := writer.String()

	maxLength := defaultMaximumTruncationLength * 2
	if vc != nil && vc.MaxTruncationLength > 0 {
		maxLength = vc.MaxTruncationLength * 10 // hard cutoff matching Strada's absoluteMaximumLength
	}
	if noTruncation {
		maxLength = noTruncationMaximumTruncationLength * 2
	}
	if maxLength > 0 && result != "" && len(result) >= maxLength {
		if vc != nil {
			vc.Truncated = true
		}
		return result[0:maxLength-len("...")] + "..."
	}