Debian Codegraph @

third_party/spirv-tools/utils/vscode/src/langsvr.go

raw
1 // Copyright (C) 2019 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // langsvr implements a Language Server for the SPIRV assembly language.
16 package main
17
18 import (
19 "context"
20 "fmt"
21 "io"
22 "io/ioutil"
23 "log"
24 "os"
25 "path"
26 "sort"
27 "strings"
28 "sync"
29 "unicode/utf8"
30
31 "./parser"
32 "./schema"
33
34 "./lsp/jsonrpc2"
35 lsp "./lsp/protocol"
36 )
37
38 // rSpy is a reader 'spy' that wraps an io.Reader, and logs all data that passes
39 // through it.
40 type rSpy struct {
41 prefix string
42 r io.Reader
43 }
44
45 func (s rSpy) Read(p []byte) (n int, err error) {
46 n, err = s.r.Read(p)
47 log.Printf("%v %v", s.prefix, string(p[:n]))
48 return n, err
49 }
50
51 // wSpy is a reader 'spy' that wraps an io.Writer, and logs all data that passes
52 // through it.
53 type wSpy struct {
54 prefix string
55 w io.Writer
56 }
57
58 func (s wSpy) Write(p []byte) (n int, err error) {
59 n, err = s.w.Write(p)
60 log.Printf("%v %v", s.prefix, string(p))
61 return n, err
62 }
63
64 // main entry point.
65 func main() {
66 // create a log file in the executable's directory.
67 if logfile, err := os.Create(path.Join(path.Dir(os.Args[0]), "log.txt")); err == nil {
68 defer logfile.Close()
69 log.SetOutput(logfile)
70 } else {
71 log.SetOutput(ioutil.Discard)
72 }
73
74 log.Println("language server started")
75
76 stream := jsonrpc2.NewHeaderStream(rSpy{"IDE", os.Stdin}, wSpy{"LS", os.Stdout})
77 s := server{
78 files: map[string]*file{},
79 }
80 s.ctx, s.conn, s.client = lsp.NewServer(context.Background(), stream, &s)
81 if err := s.conn.Run(s.ctx); err != nil {
82 log.Panicln(err)
83 os.Exit(1)
84 }
85
86 log.Println("language server stopped")
87 }
88
89 type server struct {
90 ctx context.Context
91 conn *jsonrpc2.Conn
92 client lsp.Client
93
94 files map[string]*file
95 filesMutex sync.Mutex
96 }
97
98 // file represents a source file
99 type file struct {
100 fullRange parser.Range
101 res parser.Results
102 }
103
104 // tokAt returns the parser token at the given position lp
105 func (f *file) tokAt(lp lsp.Position) *parser.Token {
106 toks := f.res.Tokens
107 p := parser.Position{Line: int(lp.Line) + 1, Column: int(lp.Character) + 1}
108 i := sort.Search(len(toks), func(i int) bool { return p.LessThan(toks[i].Range.End) })
109 if i == len(toks) {
110 return nil
111 }
112 if toks[i].Range.Contains(p) {
113 return toks[i]
114 }
115 return nil
116 }
117
118 func (s *server) DidChangeWorkspaceFolders(ctx context.Context, p *lsp.DidChangeWorkspaceFoldersParams) error {
119 log.Println("server.DidChangeWorkspaceFolders()")
120 return nil
121 }
122 func (s *server) Initialized(ctx context.Context, p *lsp.InitializedParams) error {
123 log.Println("server.Initialized()")
124 return nil
125 }
126 func (s *server) Exit(ctx context.Context) error {
127 log.Println("server.Exit()")
128 return nil
129 }
130 func (s *server) DidChangeConfiguration(ctx context.Context, p *lsp.DidChangeConfigurationParams) error {
131 log.Println("server.DidChangeConfiguration()")
132 return nil
133 }
134 func (s *server) DidOpen(ctx context.Context, p *lsp.DidOpenTextDocumentParams) error {
135 log.Println("server.DidOpen()")
136 return s.processFile(ctx, p.TextDocument.URI, p.TextDocument.Text)
137 }
138 func (s *server) DidChange(ctx context.Context, p *lsp.DidChangeTextDocumentParams) error {
139 log.Println("server.DidChange()")
140 return s.processFile(ctx, p.TextDocument.URI, p.ContentChanges[0].Text)
141 }
142 func (s *server) DidClose(ctx context.Context, p *lsp.DidCloseTextDocumentParams) error {
143 log.Println("server.DidClose()")
144 return nil
145 }
146 func (s *server) DidSave(ctx context.Context, p *lsp.DidSaveTextDocumentParams) error {
147 log.Println("server.DidSave()")
148 return nil
149 }
150 func (s *server) WillSave(ctx context.Context, p *lsp.WillSaveTextDocumentParams) error {
151 log.Println("server.WillSave()")
152 return nil
153 }
154 func (s *server) DidChangeWatchedFiles(ctx context.Context, p *lsp.DidChangeWatchedFilesParams) error {
155 log.Println("server.DidChangeWatchedFiles()")
156 return nil
157 }
158 func (s *server) Progress(ctx context.Context, p *lsp.ProgressParams) error {
159 log.Println("server.Progress()")
160 return nil
161 }
162 func (s *server) SetTraceNotification(ctx context.Context, p *lsp.SetTraceParams) error {
163 log.Println("server.SetTraceNotification()")
164 return nil
165 }
166 func (s *server) LogTraceNotification(ctx context.Context, p *lsp.LogTraceParams) error {
167 log.Println("server.LogTraceNotification()")
168 return nil
169 }
170 func (s *server) Implementation(ctx context.Context, p *lsp.ImplementationParams) ([]lsp.Location, error) {
171 log.Println("server.Implementation()")
172 return nil, nil
173 }
174 func (s *server) TypeDefinition(ctx context.Context, p *lsp.TypeDefinitionParams) ([]lsp.Location, error) {
175 log.Println("server.TypeDefinition()")
176 return nil, nil
177 }
178 func (s *server) DocumentColor(ctx context.Context, p *lsp.DocumentColorParams) ([]lsp.ColorInformation, error) {
179 log.Println("server.DocumentColor()")
180 return nil, nil
181 }
182 func (s *server) ColorPresentation(ctx context.Context, p *lsp.ColorPresentationParams) ([]lsp.ColorPresentation, error) {
183 log.Println("server.ColorPresentation()")
184 return nil, nil
185 }
186 func (s *server) FoldingRange(ctx context.Context, p *lsp.FoldingRangeParams) ([]lsp.FoldingRange, error) {
187 log.Println("server.FoldingRange()")
188 return nil, nil
189 }
190 func (s *server) Declaration(ctx context.Context, p *lsp.DeclarationParams) ([]lsp.DeclarationLink, error) {
191 log.Println("server.Declaration()")
192 return nil, nil
193 }
194 func (s *server) SelectionRange(ctx context.Context, p *lsp.SelectionRangeParams) ([]lsp.SelectionRange, error) {
195 log.Println("server.SelectionRange()")
196 return nil, nil
197 }
198 func (s *server) Initialize(ctx context.Context, p *lsp.ParamInitia) (*lsp.InitializeResult, error) {
199 log.Println("server.Initialize()")
200 res := lsp.InitializeResult{
201 Capabilities: lsp.ServerCapabilities{
202 TextDocumentSync: lsp.TextDocumentSyncOptions{
203 OpenClose: true,
204 Change: lsp.Full, // TODO: Implement incremental
205 },
206 HoverProvider: true,
207 DefinitionProvider: true,
208 ReferencesProvider: true,
209 RenameProvider: true,
210 DocumentFormattingProvider: true,
211 },
212 }
213 return &res, nil
214 }
215 func (s *server) Shutdown(ctx context.Context) error {
216 log.Println("server.Shutdown()")
217 return nil
218 }
219 func (s *server) WillSaveWaitUntil(ctx context.Context, p *lsp.WillSaveTextDocumentParams) ([]lsp.TextEdit, error) {
220 log.Println("server.WillSaveWaitUntil()")
221 return nil, nil
222 }
223 func (s *server) Completion(ctx context.Context, p *lsp.CompletionParams) (*lsp.CompletionList, error) {
224 log.Println("server.Completion()")
225 return nil, nil
226 }
227 func (s *server) Resolve(ctx context.Context, p *lsp.CompletionItem) (*lsp.CompletionItem, error) {
228 log.Println("server.Resolve()")
229 return nil, nil
230 }
231 func (s *server) Hover(ctx context.Context, p *lsp.HoverParams) (*lsp.Hover, error) {
232 log.Println("server.Hover()")
233 f := s.getFile(p.TextDocument.URI)
234 if f == nil {
235 return nil, fmt.Errorf("Unknown file")
236 }
237
238 if tok := f.tokAt(p.Position); tok != nil {
239 sb := strings.Builder{}
240 switch v := f.res.Mappings[tok].(type) {
241 default:
242 sb.WriteString(fmt.Sprintf("<Unhandled type '%T'>", v))
243 case *parser.Instruction:
244 sb.WriteString(fmt.Sprintf("```\n%v\n```", v.Opcode.Opname))
245 case *parser.Identifier:
246 sb.WriteString(fmt.Sprintf("```\n%v\n```", v.Definition.Range.Text(f.res.Lines)))
247 case *parser.Operand:
248 if v.Name != "" {
249 sb.WriteString(strings.Trim(v.Name, `'`))
250 sb.WriteString("\n\n")
251 }
252
253 switch v.Kind.Category {
254 case schema.OperandCategoryBitEnum:
255 case schema.OperandCategoryValueEnum:
256 sb.WriteString("```\n")
257 sb.WriteString(strings.Trim(v.Kind.Kind, `'`))
258 sb.WriteString("\n```")
259 case schema.OperandCategoryID:
260 if s := tok.Text(f.res.Lines); s != "" {
261 if id, ok := f.res.Identifiers[s]; ok && id.Definition != nil {
262 sb.WriteString("```\n")
263 sb.WriteString(id.Definition.Range.Text(f.res.Lines))
264 sb.WriteString("\n```")
265 }
266 }
267 case schema.OperandCategoryLiteral:
268 case schema.OperandCategoryComposite:
269 }
270 case nil:
271 }
272
273 if sb.Len() > 0 {
274 res := lsp.Hover{
275 Contents: lsp.MarkupContent{
276 Kind: "markdown",
277 Value: sb.String(),
278 },
279 }
280 return &res, nil
281 }
282 }
283
284 return nil, nil
285 }
286 func (s *server) SignatureHelp(ctx context.Context, p *lsp.SignatureHelpParams) (*lsp.SignatureHelp, error) {
287 log.Println("server.SignatureHelp()")
288 return nil, nil
289 }
290 func (s *server) Definition(ctx context.Context, p *lsp.DefinitionParams) ([]lsp.Location, error) {
291 log.Println("server.Definition()")
292 if f := s.getFile(p.TextDocument.URI); f != nil {
293 if tok := f.tokAt(p.Position); tok != nil {
294 if s := tok.Text(f.res.Lines); s != "" {
295 if id, ok := f.res.Identifiers[s]; ok {
296 loc := lsp.Location{
297 URI: p.TextDocument.URI,
298 Range: rangeToLSP(id.Definition.Range),
299 }
300 return []lsp.Location{loc}, nil
301 }
302 }
303 }
304 }
305 return nil, nil
306 }
307 func (s *server) References(ctx context.Context, p *lsp.ReferenceParams) ([]lsp.Location, error) {
308 log.Println("server.References()")
309 if f := s.getFile(p.TextDocument.URI); f != nil {
310 if tok := f.tokAt(p.Position); tok != nil {
311 if s := tok.Text(f.res.Lines); s != "" {
312 if id, ok := f.res.Identifiers[s]; ok {
313 locs := make([]lsp.Location, len(id.References))
314 for i, r := range id.References {
315 locs[i] = lsp.Location{
316 URI: p.TextDocument.URI,
317 Range: rangeToLSP(r.Range),
318 }
319 }
320 return locs, nil
321 }
322 }
323 }
324 }
325 return nil, nil
326 }
327 func (s *server) DocumentHighlight(ctx context.Context, p *lsp.DocumentHighlightParams) ([]lsp.DocumentHighlight, error) {
328 log.Println("server.DocumentHighlight()")
329 return nil, nil
330 }
331 func (s *server) DocumentSymbol(ctx context.Context, p *lsp.DocumentSymbolParams) ([]lsp.DocumentSymbol, error) {
332 log.Println("server.DocumentSymbol()")
333 return nil, nil
334 }
335 func (s *server) CodeAction(ctx context.Context, p *lsp.CodeActionParams) ([]lsp.CodeAction, error) {
336 log.Println("server.CodeAction()")
337 return nil, nil
338 }
339 func (s *server) Symbol(ctx context.Context, p *lsp.WorkspaceSymbolParams) ([]lsp.SymbolInformation, error) {
340 log.Println("server.Symbol()")
341 return nil, nil
342 }
343 func (s *server) CodeLens(ctx context.Context, p *lsp.CodeLensParams) ([]lsp.CodeLens, error) {
344 log.Println("server.CodeLens()")
345 return nil, nil
346 }
347 func (s *server) ResolveCodeLens(ctx context.Context, p *lsp.CodeLens) (*lsp.CodeLens, error) {
348 log.Println("server.ResolveCodeLens()")
349 return nil, nil
350 }
351 func (s *server) DocumentLink(ctx context.Context, p *lsp.DocumentLinkParams) ([]lsp.DocumentLink, error) {
352 log.Println("server.DocumentLink()")
353 return nil, nil
354 }
355 func (s *server) ResolveDocumentLink(ctx context.Context, p *lsp.DocumentLink) (*lsp.DocumentLink, error) {
356 log.Println("server.ResolveDocumentLink()")
357 return nil, nil
358 }
359 func (s *server) Formatting(ctx context.Context, p *lsp.DocumentFormattingParams) ([]lsp.TextEdit, error) {
360 log.Println("server.Formatting()")
361 if f := s.getFile(p.TextDocument.URI); f != nil {
362 // Start by measuring the distance from the start of each line to the
363 // first opcode on that line.
364 lineInstOffsets, maxInstOffset, instOffset, curOffset := []int{}, 0, 0, -1
365 for _, t := range f.res.Tokens {
366 curOffset++ // whitespace between tokens
367 switch t.Type {
368 case parser.Ident:
369 if _, isInst := schema.Opcodes[t.Text(f.res.Lines)]; isInst && instOffset == 0 {
370 instOffset = curOffset
371 continue
372 }
373 case parser.Newline:
374 lineInstOffsets = append(lineInstOffsets, instOffset)
375 if instOffset > maxInstOffset {
376 maxInstOffset = instOffset
377 }
378 curOffset, instOffset = -1, 0
379 default:
380 curOffset += utf8.RuneCountInString(t.Text(f.res.Lines))
381 }
382 }
383 lineInstOffsets = append(lineInstOffsets, instOffset)
384
385 // Now rewrite each of the lines, adding padding at the start of the
386 // line for alignment.
387 sb, newline := strings.Builder{}, true
388 for _, t := range f.res.Tokens {
389 if newline {
390 newline = false
391 indent := maxInstOffset - lineInstOffsets[0]
392 lineInstOffsets = lineInstOffsets[1:]
393 switch t.Type {
394 case parser.Newline, parser.Comment:
395 default:
396 for s := 0; s < indent; s++ {
397 sb.WriteRune(' ')
398 }
399 }
400 } else if t.Type != parser.Newline {
401 sb.WriteString(" ")
402 }
403
404 sb.WriteString(t.Text(f.res.Lines))
405 if t.Type == parser.Newline {
406 newline = true
407 }
408 }
409
410 // Every good file ends with a new line.
411 sb.WriteString("\n")
412
413 return []lsp.TextEdit{
414 lsp.TextEdit{
415 Range: rangeToLSP(f.fullRange),
416 NewText: sb.String(),
417 },
418 }, nil
419 }
420 return nil, nil
421 }
422 func (s *server) RangeFormatting(ctx context.Context, p *lsp.DocumentRangeFormattingParams) ([]lsp.TextEdit, error) {
423 log.Println("server.RangeFormatting()")
424 return nil, nil
425 }
426 func (s *server) OnTypeFormatting(ctx context.Context, p *lsp.DocumentOnTypeFormattingParams) ([]lsp.TextEdit, error) {
427 log.Println("server.OnTypeFormatting()")
428 return nil, nil
429 }
430 func (s *server) Rename(ctx context.Context, p *lsp.RenameParams) (*lsp.WorkspaceEdit, error) {
431 log.Println("server.Rename()")
432 if f := s.getFile(p.TextDocument.URI); f != nil {
433 if tok := f.tokAt(p.Position); tok != nil {
434 if s := tok.Text(f.res.Lines); s != "" {
435 if id, ok := f.res.Identifiers[s]; ok {
436 changes := make([]lsp.TextEdit, len(id.References))
437 for i, r := range id.References {
438 changes[i].Range = rangeToLSP(r.Range)
439 changes[i].NewText = p.NewName
440 }
441 m := map[string][]lsp.TextEdit{}
442 m[p.TextDocument.URI] = changes
443 return &lsp.WorkspaceEdit{Changes: &m}, nil
444 }
445 }
446 }
447 }
448 return nil, nil
449 }
450 func (s *server) PrepareRename(ctx context.Context, p *lsp.PrepareRenameParams) (*lsp.Range, error) {
451 log.Println("server.PrepareRename()")
452 return nil, nil
453 }
454 func (s *server) ExecuteCommand(ctx context.Context, p *lsp.ExecuteCommandParams) (interface{}, error) {
455 log.Println("server.ExecuteCommand()")
456 return nil, nil
457 }
458
459 func (s *server) processFile(ctx context.Context, uri, source string) error {
460 log.Println("server.DidOpen()")
461 res, err := parser.Parse(source)
462 if err != nil {
463 return err
464 }
465 fullRange := parser.Range{
466 Start: parser.Position{Line: 1, Column: 1},
467 End: parser.Position{Line: len(res.Lines), Column: utf8.RuneCountInString(res.Lines[len(res.Lines)-1]) + 1},
468 }
469
470 s.filesMutex.Lock()
471 s.files[uri] = &file{
472 fullRange: fullRange,
473 res: res,
474 }
475 s.filesMutex.Unlock()
476
477 dp := lsp.PublishDiagnosticsParams{URI: uri, Diagnostics: make([]lsp.Diagnostic, len(res.Diagnostics))}
478 for i, d := range res.Diagnostics {
479 dp.Diagnostics[i] = diagnosticToLSP(d)
480 }
481 s.client.PublishDiagnostics(ctx, &dp)
482 return nil
483 }
484
485 func (s *server) getFile(uri string) *file {
486 s.filesMutex.Lock()
487 defer s.filesMutex.Unlock()
488 return s.files[uri]
489 }
490
491 func diagnosticToLSP(d parser.Diagnostic) lsp.Diagnostic {
492 return lsp.Diagnostic{
493 Range: rangeToLSP(d.Range),
494 Severity: severityToLSP(d.Severity),
495 Message: d.Message,
496 }
497 }
498
499 func severityToLSP(s parser.Severity) lsp.DiagnosticSeverity {
500 switch s {
501 case parser.SeverityError:
502 return lsp.SeverityError
503 case parser.SeverityWarning:
504 return lsp.SeverityWarning
505 case parser.SeverityInformation:
506 return lsp.SeverityInformation
507 case parser.SeverityHint:
508 return lsp.SeverityHint
509 default:
510 log.Panicf("Invalid severity '%d'", int(s))
511 return lsp.SeverityError
512 }
513 }
514
515 func rangeToLSP(r parser.Range) lsp.Range {
516 return lsp.Range{
517 Start: positionToLSP(r.Start),
518 End: positionToLSP(r.End),
519 }
520 }
521
522 func positionToLSP(r parser.Position) lsp.Position {
523 return lsp.Position{
524 Line: float64(r.Line - 1),
525 Character: float64(r.Column - 1),
526 }
527 }