vendor tsgo

tools/tsgo/internal/lsp/logger.go

@@ -0,0 +1,184 @@
+package lsp
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/project/logging"
+)
+
+var _ logging.Logger = (*logger)(nil)
+
+type logger struct {
+	server    *Server
+	mu        sync.Mutex
+	verbosity lsproto.LogVerbosity
+}
+
+func newLogger(server *Server) *logger {
+	return &logger{
+		server:    server,
+		verbosity: lsproto.LogVerbosityInfo,
+	}
+}
+
+// maxVerbosityForMessageType returns the least-verbose log level at which
+// messages of the given LSP MessageType should still be sent.
+func maxVerbosityForMessageType(msgType lsproto.MessageType) lsproto.LogVerbosity {
+	switch msgType {
+	case lsproto.MessageTypeError:
+		return lsproto.LogVerbosityError
+	case lsproto.MessageTypeWarning:
+		return lsproto.LogVerbosityWarning
+	case lsproto.MessageTypeInfo:
+		return lsproto.LogVerbosityInfo
+	case lsproto.MessageTypeDebug:
+		return lsproto.LogVerbosityDebug
+	default:
+		return lsproto.LogVerbosityInfo
+	}
+}
+
+// isValidLogVerbosity reports whether v is one of the defined LogVerbosity values.
+func isValidLogVerbosity(v lsproto.LogVerbosity) bool {
+	return v >= lsproto.LogVerbosityOff && v <= lsproto.LogVerbosityError
+}
+
+func (l *logger) sendLogMessage(msgType lsproto.MessageType, message string) {
+	if l == nil {
+		return
+	}
+
+	if !l.server.initStarted.Load() {
+		fmt.Fprintln(l.server.stderr, message)
+		return
+	}
+
+	// Don't send messages that the client will filter out anyway.
+	l.mu.Lock()
+	verbosity := l.verbosity
+	l.mu.Unlock()
+	if verbosity == lsproto.LogVerbosityOff || verbosity > maxVerbosityForMessageType(msgType) {
+		return
+	}
+
+	notification := lsproto.WindowLogMessageInfo.NewNotificationMessage(&lsproto.LogMessageParams{
+		Type:    msgType,
+		Message: message,
+	})
+
+	if err := l.server.outgoingQueue.Put(l.server.backgroundCtx, notification.Message()); err != nil {
+		if l.server.backgroundCtx.Err() != nil {
+			fmt.Fprintln(l.server.stderr, message)
+		}
+	}
+}
+
+func (l *logger) Log(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprint(msg...))
+}
+
+func (l *logger) Logf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Verbose() logging.Logger {
+	if l == nil {
+		return nil
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.verbosity == lsproto.LogVerbosityOff || l.verbosity > lsproto.LogVerbosityDebug {
+		return nil
+	}
+	return l
+}
+
+func (l *logger) IsVerbose() bool {
+	if l == nil {
+		return false
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.verbosity >= lsproto.LogVerbosityTrace && l.verbosity <= lsproto.LogVerbosityDebug
+}
+
+func (l *logger) SetVerbose(verbose bool) {
+	if l == nil {
+		return
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if verbose {
+		l.verbosity = lsproto.LogVerbosityDebug
+	} else {
+		l.verbosity = lsproto.LogVerbosityInfo
+	}
+}
+
+func (l *logger) IsTracing() bool {
+	if l == nil {
+		return false
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.verbosity == lsproto.LogVerbosityTrace
+}
+
+func (l *logger) SetVerbosity(verbosity lsproto.LogVerbosity) {
+	if l == nil {
+		return
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.verbosity = verbosity
+}
+
+func (l *logger) Error(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeError, fmt.Sprint(msg...))
+}
+
+func (l *logger) Errorf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeError, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Warn(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeWarning, fmt.Sprint(msg...))
+}
+
+func (l *logger) Warnf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeWarning, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Info(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprint(msg...))
+}
+
+func (l *logger) Infof(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprintf(format, args...))
+}