git.roojs.org Git - roobuilder/blob - src/Lsp.vala

   1 /* protocol.vala
   2  *
   3  * Copyright 2017-2019 Ben Iofel <ben@iofel.me>
   4  * Copyright 2017-2020 Princeton Ferro <princetonferro@gmail.com>
   5  * Copyright 2020 Sergii Fesenko <s.fesenko@outlook.com>
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Lesser General Public License as published by
   9  * the Free Software Foundation, either version 2.1 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 namespace Lsp {
  22     /**
  23      * Defines how the host (editor) should sync document changes to the language server.
  24      */
  25     [CCode (default_value = "LSP_TEXT_DOCUMENT_SYNC_KIND_Unset")]
  26     public enum TextDocumentSyncKind {
  27         Unset = -1,
  28         /**
  29          * Documents should not be synced at all.
  30          */
  31         None = 0,
  32         /**
  33          * Documents are synced by always sending the full content of the document.
  34          */
  35         Full = 1,
  36         /**
  37          * Documents are synced by sending the full content on open. After that only incremental
  38          * updates to the document are sent.
  39          */
  40         Incremental = 2
  41     }
  42
  43     public  enum DiagnosticSeverity {
  44         Unset = 0,
  45         /**
  46          * Reports an error.
  47          */
  48         Error = 1,
  49         /**
  50          * Reports a warning.
  51          */
  52         Warning = 2,
  53         /**
  54          * Reports an information.
  55          */
  56         Information = 3,
  57         /**
  58          * Reports a hint.
  59          */
  60         Hint = 4
  61
  62     }
  63
  64     public  class Position : Object, Gee.Comparable<Position> {
  65         /**
  66          * Line position in a document (zero-based).
  67          */
  68         public uint line { get; set; default = -1; }
  69
  70         /**
  71          * Character offset on a line in a document (zero-based). Assuming that the line is
  72          * represented as a string, the `character` value represents the gap between the
  73          * `character` and `character + 1`.
  74          *
  75          * If the character value is greater than the line length it defaults back to the
  76          * line length.
  77          */
  78         public uint character { get; set; default = -1; }
  79
  80         public int compare_to (Position other) {
  81             return line > other.line ? 1 :
  82                 (line == other.line ?
  83                  (character > other.character ? 1 :
  84                   (character == other.character ? 0 : -1)) : -1);
  85         }
  86         public bool equals(Position o) {
  87                 return o.line == this.line && o.character == this.character;
  88         }
  89
  90         public string to_string () {
  91             return @"$line:$character";
  92         }
  93
  94         public Position.from_libvala (Vala.SourceLocation sloc) {
  95             line = sloc.line - 1;
  96             character = sloc.column;
  97         }
  98
  99         public Position dup () {
 100             return this.translate ();
 101         }
 102
 103         public Position translate (int dl = 0, int dc = 0) {
 104             return new Position () {
 105                 line = this.line + dl,
 106                 character = this.character + dc
 107             };
 108         }
 109     }
 110
 111     public class Range : Object, Gee.Hashable<Range>, Gee.Comparable<Range> {
 112
 113         public Range.simple(uint line, uint pos) {
 114                 var p =  new Position () {
 115                 line = line,
 116                 character = pos
 117             };
 118                 this.start = p;
 119                 this.end = p;
 120
 121         }
 122         /**
 123          * The range's start position.
 124          */
 125         public Position start { get; set; }
 126
 127         /**
 128          * The range's end position.
 129          */
 130         public Position end { get; set; }
 131
 132         private string? filename;
 133
 134         public string to_string () { return (filename != null ? @"$filename:" : "") + @"$start -> $end"; }
 135
 136         public Range.from_pos (Position pos) {
 137             this.start = pos;
 138             this.end = pos.dup ();
 139         }
 140
 141         public Range.from_sourceref (Vala.SourceReference sref) {
 142             this.start = new Position.from_libvala (sref.begin);
 143             this.end = new Position.from_libvala (sref.end);
 144             this.start.character -= 1;
 145             this.filename = sref.file.filename;
 146         }
 147
 148         public uint hash () {
 149             return this.to_string ().hash ();
 150         }
 151
 152         public bool equal_to (Range other) { return this.to_string () == other.to_string (); }
 153                 public bool equals (Range o) {
 154                         return this.filename == o.filename && this.start.equals(o.start) && this.end.equals(o.end);
 155                 }
 156
 157         public int compare_to (Range other) {
 158             return start.compare_to (other.start);
 159         }
 160
 161         /**
 162          * Return a new range that includes `this` and `other`.
 163          */
 164         public Range union (Range other) {
 165             var range = new Range () {
 166                 start = start.compare_to (other.start) < 0 ? start : other.start,
 167                 end = end.compare_to (other.end) < 0 ? other.end : end,
 168             };
 169             if (filename == other.filename)
 170                 range.filename = filename;
 171             return range;
 172         }
 173
 174         public bool contains (Position pos) {
 175             return start.compare_to (pos) <= 0 && pos.compare_to (end) <= 0;
 176         }
 177
 178     }
 179
 180     public class Diagnostic : Object {
 181
 182         public Diagnostic.simple ( int line, int character, string message)
 183         {
 184                 this.message = message;
 185                 this.severity = DiagnosticSeverity.Error;
 186                 this.range =  new Range.simple(line, character );
 187
 188
 189
 190         }
 191         /**
 192          * The range at which the message applies.
 193          */
 194         public Range range { get; set; }
 195
 196         /**
 197          * The diagnostic's severity. Can be omitted. If omitted it is up to the
 198          * client to interpret diagnostics as error, warning, info or hint.
 199          */
 200         public DiagnosticSeverity severity { get; set; }
 201
 202         /**
 203          * The diagnostic's code. Can be omitted.
 204          */
 205         public string? code { get; set; }
 206
 207         /**
 208          * A human-readable string describing the source of this
 209          * diagnostic, e.g. 'typescript' or 'super lint'.
 210          */
 211         public string? source { get; set; }
 212
 213         /**
 214          * The diagnostic's message.
 215          */
 216         public string message { get; set; }
 217
 218
 219         public string category {
 220                 get {
 221                         switch(this.severity) {
 222
 223                                 case DiagnosticSeverity.Error :
 224                                         return "ERR";
 225                                 case DiagnosticSeverity.Warning :
 226                                         return this.message.contains("deprecated") ? "DEPR" : "WARN";
 227                                 default :
 228                                         return "WARN";
 229                         }
 230                 }
 231                 private set {}
 232
 233         }
 234         public bool equals(Lsp.Diagnostic o) {
 235                 var ret = this.range.equals(o.range) && this.severity == o.severity && this.message == o.message;
 236                 //GLib.debug("compare %s  (%s == %s)", ret ? "YES" : "NO", this.to_string(), o.to_string());
 237
 238
 239                 return ret;
 240         }
 241         public string to_string()
 242         {
 243                 return "%s : %d - %s".printf(this.category, (int) this.range.start.line , this.message);
 244         }
 245
 246     }
 247
 248     /**
 249      * An event describing a change to a text document. If range and rangeLength are omitted
 250      * the new text is considered to be the full content of the document.
 251      */
 252     public class TextDocumentContentChangeEvent : Object {
 253         public Range? range    { get; set; }
 254         public int rangeLength { get; set; }
 255         public string text     { get; set; }
 256     }
 257
 258     public enum MessageType {
 259         /**
 260          * An error message.
 261          */
 262         Error = 1,
 263         /**
 264          * A warning message.
 265          */
 266         Warning = 2,
 267         /**
 268          * An information message.
 269          */
 270         Info = 3,
 271         /**
 272          * A log message.
 273          */
 274         Log = 4
 275     }
 276
 277     public class TextDocumentIdentifier : Object {
 278         public string uri { get; set; }
 279     }
 280
 281     public class VersionedTextDocumentIdentifier : TextDocumentIdentifier {
 282         /**
 283          * The version number of this document. If a versioned text document identifier
 284          * is sent from the server to the client and the file is not open in the editor
 285          * (the server has not received an open notification before) the server can send
 286          * `null` to indicate that the version is known and the content on disk is the
 287          * master (as speced with document content ownership).
 288          *
 289          * The version number of a document will increase after each change, including
 290          * undo/redo. The number doesn't need to be consecutive.
 291          */
 292         public int version { get; set; default = -1; }
 293     }
 294
 295     public class TextDocumentPositionParams : Object {
 296         public TextDocumentIdentifier textDocument { get; set; }
 297         public Position position { get; set; }
 298     }
 299
 300     public class ReferenceParams : TextDocumentPositionParams {
 301         public class ReferenceContext : Object {
 302             public bool includeDeclaration { get; set; }
 303         }
 304         public ReferenceContext? context { get; set; }
 305     }
 306
 307     public class Location : Object {
 308         public string uri { get; set; }
 309         public Range range { get; set; }
 310
 311         public Location.from_sourceref (Vala.SourceReference sref) {
 312             this (sref.file.filename, new Range.from_sourceref (sref));
 313         }
 314
 315         public Location (string filename, Range range) {
 316             this.uri = File.new_for_commandline_arg (filename).get_uri ();
 317             this.range = range;
 318         }
 319     }
 320
 321     [CCode (default_value = "LSP_DOCUMENT_HIGHLIGHT_KIND_Text")]
 322     public enum DocumentHighlightKind {
 323         Text = 1,
 324         Read = 2,
 325         Write = 3
 326     }
 327
 328     public class DocumentHighlight : Object {
 329         public Range range { get; set; }
 330         public DocumentHighlightKind kind { get; set; }
 331     }
 332
 333     public class DocumentSymbolParams: Object {
 334         public TextDocumentIdentifier textDocument { get; set; }
 335     }
 336
 337     public class DocumentSymbol : Object, Json.Serializable {
 338         private Vala.SourceReference? _source_reference;
 339         public string name { get; set; }
 340         public string? detail { get; set; }
 341         public SymbolKind kind { get; set; }
 342         public bool deprecated { get; set; }
 343         private Range? _initial_range;
 344         public Range range {
 345             owned get {
 346                 if (_initial_range == null)
 347                     _initial_range = new Range.from_sourceref (children.first ()._source_reference);
 348
 349                 return children.fold<Range> ((child, current_range) => current_range.union (child.range), _initial_range);
 350             }
 351         }
 352         public Range selectionRange { get; set; }
 353         public Gee.List<DocumentSymbol> children { get; private set; default = new Gee.LinkedList<DocumentSymbol> (); }
 354         public string? parent_name;
 355
 356         private DocumentSymbol () {}
 357
 358         /**
 359          * @param type the data type containing this symbol, if there was one (not available for Namespaces, for example)
 360          * @param sym the symbol
 361          */
 362          /*
 363         public DocumentSymbol.from_vala_symbol (Vala.DataType? type, Vala.Symbol sym, SymbolKind kind) {
 364             this.parent_name = sym.parent_symbol != null ? sym.parent_symbol.name : null;
 365             this._initial_range = new Range.from_sourceref (sym.source_reference);
 366             if (sym is Vala.Subroutine) {
 367                 var sub = (Vala.Subroutine) sym;
 368                 var body_sref = sub.body != null ? sub.body.source_reference : null;
 369                 // debug ("subroutine %s found (body @ %s)", sym.get_full_name (),
 370                 //         body_sref != null ? body_sref.to_string () : null);
 371                 if (body_sref != null && (body_sref.begin.line < body_sref.end.line ||
 372                                 val = GLib.Value (typeof(Gee.ArrayList));                          body_sref.begin.line == body_sref.end.line && body_sref.begin.pos <= body_sref.end.pos)) {
 373                     this._initial_range = this._initial_range.union (new Range.from_sourceref (body_sref));
 374                 }
 375             }
 376             this.name = sym.name;
 377             this.detail = Vls.CodeHelp.get_symbol_representation (type, sym, null, false);
 378             this.kind = kind;
 379             this.selectionRange = new Range.from_sourceref (sym.source_reference);
 380             this.deprecated = sym.version.deprecated;
 381         }
 382         */
 383         public new void Json.Serializable.set_property (ParamSpec pspec, Value value) {
 384             base.set_property (pspec.get_name (), value);
 385         }
 386
 387         public new Value Json.Serializable.get_property (ParamSpec pspec) {
 388             Value val = Value (pspec.value_type);
 389             base.get_property (pspec.get_name (), ref val);
 390             return val;
 391         }
 392
 393         public unowned ParamSpec? find_property (string name) {
 394             return this.get_class ().find_property (name);
 395         }
 396
 397         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 398             if (property_name != "children")
 399                 return default_serialize_property (property_name, value, pspec);
 400             var node = new Json.Node (Json.NodeType.ARRAY);
 401             node.init_array (new Json.Array ());
 402             var array = node.get_array ();
 403             foreach (var child in children)
 404                 array.add_element (Json.gobject_serialize (child));
 405             return node;
 406         }
 407
 408         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node)
 409             {
 410
 411                 if (property_name != "children") {
 412                     return default_deserialize_property (property_name, out value, pspec, property_node);
 413                 }
 414             value = GLib.Value (typeof(Gee.ArrayList));
 415                 if (property_node.get_node_type () != Json.NodeType.ARRAY) {
 416                     warning ("unexpected property node type for 'arguments' %s", property_node.get_node_type ().to_string ());
 417                     return false;
 418                 }
 419
 420                 var arguments = new Gee.ArrayList<DocumentSymbol>();
 421
 422                 property_node.get_array ().foreach_element ((array, index, element) => {
 423
 424                         var add= Json.gobject_deserialize ( typeof (DocumentSymbol),  array.get_element(index)) as DocumentSymbol;
 425                                 arguments.add( add);
 426
 427
 428                 });
 429
 430                 value.set_object (arguments);
 431                 return true;
 432            }
 433     }
 434
 435     public class SymbolInformation : Object {
 436         public string name { get; set; }
 437         public SymbolKind kind { get; set; }
 438         public Location location { get; set; }
 439         public string? containerName { get; set; }
 440
 441         public SymbolInformation.from_document_symbol (DocumentSymbol dsym, string uri) {
 442             this.name = dsym.name;
 443             this.kind = dsym.kind;
 444             this.location = new Location (uri, dsym.range);
 445             this.containerName = dsym.parent_name;
 446         }
 447     }
 448
 449     [CCode (default_value = "LSP_SYMBOL_KIND_Variable")]
 450     public enum SymbolKind {
 451         File = 1,
 452         Module = 2,
 453         Namespace = 3,
 454         Package = 4,
 455         Class = 5,
 456         Method = 6,
 457         Property = 7,
 458         Field = 8,
 459         Constructor = 9,
 460         Enum = 10,
 461         Interface = 11,
 462         Function = 12,
 463         Variable = 13,
 464         Constant = 14,
 465         String = 15,
 466         Number = 16,
 467         Boolean = 17,
 468         Array = 18,
 469         Object = 19,
 470         Key = 20,
 471         Null = 21,
 472         EnumMember = 22,
 473         Struct = 23,
 474         Event = 24,
 475         Operator = 25,
 476         TypeParameter = 26
 477     }
 478
 479         public class CompletionList : Object, Json.Serializable {
 480         public bool isIncomplete { get; set; }
 481         public Gee.List<CompletionItem> items { get; private set; default = new Gee.LinkedList<CompletionItem> (); }
 482
 483         public new void Json.Serializable.set_property (ParamSpec pspec, Value value) {
 484             base.set_property (pspec.get_name (), value);
 485         }
 486
 487         public new Value Json.Serializable.get_property (ParamSpec pspec) {
 488             Value val = Value(pspec.value_type);
 489             base.get_property (pspec.get_name (), ref val);
 490             return val;
 491         }
 492
 493         public unowned ParamSpec? find_property (string name) {
 494             return this.get_class ().find_property (name);
 495         }
 496
 497         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 498             if (property_name != "items")
 499                 return default_serialize_property (property_name, value, pspec);
 500             var node = new Json.Node (Json.NodeType.ARRAY);
 501             node.init_array (new Json.Array ());
 502             var array = node.get_array ();
 503             foreach (var child in items)
 504                 array.add_element (Json.gobject_serialize (child));
 505             return node;
 506         }
 507
 508         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 509             error ("deserialization not supported");
 510         }
 511     }
 512
 513     [CCode (default_value = "LSP_COMPLETION_TRIGGER_KIND_Invoked")]
 514     public enum CompletionTriggerKind {
 515         /**
 516              * Completion was triggered by typing an identifier (24x7 code
 517              * complete), manual invocation (e.g Ctrl+Space) or via API.
 518              */
 519         Invoked = 1,
 520
 521         /**
 522              * Completion was triggered by a trigger character specified by
 523              * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
 524              */
 525         TriggerCharacter = 2,
 526
 527         /**
 528              * Completion was re-triggered as the current completion list is incomplete.
 529              */
 530         TriggerForIncompleteCompletions = 3
 531     }
 532
 533     public class CompletionContext : Object {
 534         public CompletionTriggerKind triggerKind { get; set;}
 535         public string? triggerCharacter { get; set; }
 536     }
 537
 538     public class CompletionParams : TextDocumentPositionParams {
 539         /**
 540          * The completion context. This is only available if the client specifies
 541          * to send this using `ClientCapabilities.textDocument.completion.contextSupport === true`
 542          */
 543         public CompletionContext? context { get; set; }
 544     }
 545
 546     public enum CompletionItemTag {
 547         // Render a completion as obsolete, usually using a strike-out.
 548         Deprecated = 1,
 549     }
 550
 551     [CCode (default_value = "LSP_INSERT_TEXT_FORMAT_PlainText")]
 552     public enum InsertTextFormat {
 553         /**
 554          * The primary text to be inserted is treated as a plain string.
 555          */
 556         PlainText = 1,
 557
 558         /**
 559          * The primary text to be inserted is treated as a snippet.
 560          *
 561          * A snippet can define tab stops and placeholders with `$1`, `$2`
 562          * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
 563          * the end of the snippet. Placeholders with equal identifiers are linked,
 564          * that is typing in one will update others too.
 565          */
 566         Snippet = 2,
 567     }
 568
 569     public class CompletionItem : Object, Gee.Hashable<CompletionItem>, Json.Serializable {
 570         public string label { get; set; }
 571         public CompletionItemKind kind { get; set; }
 572         public string detail { get; set; }
 573         public MarkupContent? documentation { get; set; }
 574         public bool deprecated { get; set; }
 575         public Gee.List<CompletionItemTag> tags { get; private set; default = new Gee.ArrayList<CompletionItemTag> (); }
 576         public string? insertText { get; set; }
 577         public InsertTextFormat insertTextFormat { get; set; default = InsertTextFormat.PlainText; }
 578         private uint _hash;
 579
 580         private CompletionItem () {}
 581
 582         public CompletionItem.keyword (string keyword, string? insert_text = null, string? documentation = null) {
 583             this.label = keyword;
 584             this.kind = CompletionItemKind.Keyword;
 585             this.insertText = insert_text;
 586             if (insert_text != null && (insert_text.contains ("$0") || insert_text.contains ("${0")))
 587                 this.insertTextFormat = InsertTextFormat.Snippet;
 588             if (documentation != null)
 589                 this.documentation = new MarkupContent.from_plaintext (documentation);
 590             this._hash = @"$label $kind".hash ();
 591         }
 592
 593         /**
 594          * A completion suggestion from an existing Vala symbol.
 595          *
 596          * @param instance_type the parent data type of data type of the expression where this symbol appears, or null
 597          * @param sym the symbol itself
 598          * @param scope the scope to display this in
 599          * @param kind the kind of completion to display
 600          * @param documentation the documentation to display
 601          * @param label_override if non-null, override the displayed symbol name with this
 602          */
 603          /*
 604         public CompletionItem.from_symbol (Vala.DataType? instance_type, Vala.Symbol sym, Vala.Scope? scope,
 605             CompletionItemKind kind,
 606             Vls.DocComment? documentation, string? label_override = null) {
 607             this.label = label_override ?? sym.name;
 608             this.kind = kind;
 609             this.detail = Vls.CodeHelp.get_symbol_representation (instance_type, sym, scope, true, null, label_override, false);
 610             this._hash = @"$label $kind".hash ();
 611
 612             if (documentation != null)
 613                 this.documentation = new MarkupContent.from_markdown (documentation.body);
 614
 615             var version = sym.get_attribute ("Version");
 616             if (version != null && (version.get_bool ("deprecated") || version.get_string ("deprecated_since") != null)) {
 617                 this.tags.add (CompletionItemTag.Deprecated);
 618                 this.deprecated = true;
 619             }public
 620         }
 621                 */
 622         /**
 623          * A completion suggestion from a data type and a synthetic symbol name.
 624          *
 625          * @param symbol_type       the data type of the symbol
 626          * @param symbol_name       the name of the synthetic symbol
 627          * @param scope             the scope that this completion item is displayed in, or null
 628          * @param kind              the type of completion to display
 629          * @param documentation     the documentation for this symbol, or null
 630          */
 631          /*
 632         public CompletionItem.from_synthetic_symbol (Vala.DataType symbol_type, string symbol_name, Vala.Scope? scope,
 633                                                      CompletionItemKind kind, Vls.DocComment? documentation) {
 634             this.label = symbol_name;
 635             this.kind = kind;
 636             this.detail = @"$(Vls.CodeHelp.get_symbol_representation (symbol_type, null, scope, true, null, null, false)) $symbol_name";
 637             this._hash = @"$label $kind".hash ();
 638
 639             if (documentation != null)
 640                 this.documentation = new MarkupContent.from_markdown (documentation.body);
 641         }
 642         */
 643                 /*
 644         public CompletionItem.from_unimplemented_symbol (Vala.Symbol sym,
 645                                                          string label, CompletionItemKind kind,
 646                                                          string insert_text,
 647                                                          Vls.DocComment? documentation) {
 648             this.label = label;
 649             this.kind = kind;
 650             this.insertText = insert_text;
 651             if (insert_text.contains ("$0") || insert_text.contains ("${0"))
 652                 this.insertTextFormat = InsertTextFormat.Snippet;
 653             this._hash = @"$label $kind".hash ();
 654             if (documentation != null)
 655                 this.documentation = new MarkupContent.from_markdown (documentation.body);
 656         }
 657         */
 658
 659         public uint hash () {
 660             return this._hash;
 661         }
 662
 663         public bool equal_to (CompletionItem other) {
 664             return other.label == this.label && other.kind == this.kind;
 665         }
 666
 667         public new void Json.Serializable.set_property (ParamSpec pspec, Value value) {
 668             base.set_property (pspec.get_name (), value);
 669         }
 670
 671         public new Value Json.Serializable.get_property (ParamSpec pspec) {
 672             Value val = Value(pspec.value_type);
 673             base.get_property (pspec.get_name (), ref val);
 674             return val;
 675         }
 676
 677         public unowned ParamSpec? find_property (string name) {
 678             return this.get_class ().find_property (name);
 679         }
 680
 681         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 682             if (property_name != "tags")
 683                 return default_serialize_property (property_name, value, pspec);
 684
 685             var node = new Json.Node (Json.NodeType.ARRAY);
 686             node.init_array (new Json.Array ());
 687             var array = node.get_array ();
 688             foreach (var tag in this.tags) {
 689                 array.add_int_element (tag);
 690             }
 691
 692             return node;
 693         }
 694         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node)
 695         {
 696                 if (property_name != "tags") {
 697                 return default_deserialize_property (property_name, out value, pspec, property_node);
 698             }
 699             value = GLib.Value (typeof(Gee.ArrayList));
 700             if (property_node.get_node_type () != Json.NodeType.ARRAY) {
 701                 warning ("unexpected property node type for 'arguments' %s", property_node.get_node_type ().to_string ());
 702                 return false;
 703             }
 704
 705             var arguments = new Gee.ArrayList<CompletionItemTag>();
 706
 707             property_node.get_array ().foreach_element ((array, index, element) => {
 708                 try {
 709                     arguments.add ((CompletionItemTag) Json.gvariant_deserialize (element, null).get_int32() );
 710                 } catch (Error e) {
 711                     warning ("argument %u to command could not be deserialized: %s", index, e.message);
 712                 }
 713             });
 714
 715             value.set_object (arguments);
 716             return true;
 717        }
 718     }
 719
 720     public class MarkupContent : Object {
 721         public string kind { get; set; }
 722         public string value { get; set; }
 723
 724         private MarkupContent () {}
 725
 726         /**
 727          * Create a MarkupContent with plain text.
 728          */
 729         public MarkupContent.from_plaintext (string doc) {
 730             this.kind = "plaintext";
 731             this.value = doc;
 732         }
 733
 734         /**
 735          * Create a MarkupContent with markdown text.
 736          */
 737         public MarkupContent.from_markdown (string doc) {
 738             this.kind = "markdown";
 739             this.value = doc;
 740         }
 741     }
 742
 743     [CCode (default_value = "LSP_COMPLETION_ITEM_KIND_Text")]
 744     public enum CompletionItemKind {
 745         Text = 1,
 746         Method = 2,
 747         Function = 3,
 748         Constructor = 4,
 749         Field = 5,
 750         Variable = 6,
 751         Class = 7,
 752         Interface = 8,
 753         Module = 9,
 754         Property = 10,
 755         Unit = 11,
 756         Value = 12,
 757         Enum = 13,
 758         Keyword = 14,
 759         Snippet = 15,
 760         Color = 16,
 761         File = 17,
 762         Reference = 18,
 763         Folder = 19,
 764         EnumMember = 20,
 765         Constant = 21,
 766         Struct = 22,
 767         Event = 23,
 768         Operator = 24,
 769         TypeParameter = 25
 770     }
 771
 772     /**
 773      * Capabilities of the client/editor for `textDocument/documentSymbol`
 774      */
 775     public class DocumentSymbolCapabilities : Object {
 776         public bool hierarchicalDocumentSymbolSupport { get; set; }
 777     }
 778
 779     /**
 780      * Capabilities of the client/editor for `textDocument/rename`
 781      */
 782     public class RenameClientCapabilities : Object {
 783         public bool prepareSupport { get; set; }
 784     }
 785
 786     /**
 787      * Capabilities of the client/editor pertaining to language features.
 788      */
 789     public class TextDocumentClientCapabilities : Object {
 790         public DocumentSymbolCapabilities documentSymbol { get; set; default = new DocumentSymbolCapabilities ();}
 791         public RenameClientCapabilities rename { get; set; default = new RenameClientCapabilities (); }
 792     }
 793
 794     /**
 795      * Capabilities of the client/editor.
 796      */
 797     public class ClientCapabilities : Object {
 798         public TextDocumentClientCapabilities textDocument { get; set; default = new TextDocumentClientCapabilities (); }
 799     }
 800
 801     public class InitializeParams : Object {
 802         public int processId { get; set; }
 803         public string? rootPath { get; set; }
 804         public string? rootUri { get; set; }
 805         public ClientCapabilities capabilities { get; set; default = new ClientCapabilities (); }
 806     }
 807
 808     public class SignatureInformation : Object, Json.Serializable {
 809         public string label { get; set; }
 810         public MarkupContent documentation { get; set; }
 811
 812         public Gee.List<ParameterInformation> parameters { get; private set; default = new Gee.LinkedList<ParameterInformation> (); }
 813
 814         public new void Json.Serializable.set_property (ParamSpec pspec, Value value) {
 815             base.set_property (pspec.get_name (), value);
 816         }
 817
 818         public new Value Json.Serializable.get_property (ParamSpec pspec) {
 819             Value val = Value(pspec.value_type);
 820             base.get_property (pspec.get_name (), ref val);
 821             return val;
 822         }
 823
 824         public unowned ParamSpec? find_property (string name) {
 825             return this.get_class ().find_property (name);
 826         }
 827
 828         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 829             if (property_name != "parameters")
 830                 return default_serialize_property (property_name, value, pspec);
 831             var node = new Json.Node (Json.NodeType.ARRAY);
 832             node.init_array (new Json.Array ());
 833             var array = node.get_array ();
 834             foreach (var child in parameters)
 835                 array.add_element (Json.gobject_serialize (child));
 836             return node;
 837         }
 838
 839         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 840             error ("deserialization not supported");
 841         }
 842     }
 843
 844     public class SignatureHelp : Object, Json.Serializable {
 845         public Gee.Collection<SignatureInformation> signatures { get; set; default = new Gee.ArrayList<SignatureInformation> (); }
 846         public int activeSignature { get; set; }
 847         public int activeParameter { get; set; }
 848
 849         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 850             if (property_name != "signatures")
 851                 return default_serialize_property (property_name, value, pspec);
 852
 853             var node = new Json.Node (Json.NodeType.ARRAY);
 854             node.init_array (new Json.Array ());
 855             var array = node.get_array ();
 856             foreach (var child in signatures)
 857                 array.add_element (Json.gobject_serialize (child));
 858             return node;
 859         }
 860
 861         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
 862             error ("deserialization not supported");
 863         }
 864     }
 865
 866     public class ParameterInformation : Object {
 867         public string label { get; set; }
 868         public MarkupContent documentation { get; set; }
 869     }
 870
 871    public  class MarkedString : Object {
 872                 public MarkedString(string language, string value)
 873                 {
 874                         this.language = language;
 875                         this.value = value;
 876                         GLib.debug("new marked string %s : %s", language, value);
 877                 }
 878         public string language { get; set; }
 879         public string value { get; set; }
 880     }
 881
 882     public class Hover : Object, Json.Serializable {
 883         public Gee.List<MarkedString> contents { get; set; default = new Gee.ArrayList<MarkedString> (); }
 884         public Range range { get; set; }
 885
 886         public new void Json.Serializable.set_property (ParamSpec pspec, Value value) {
 887             base.set_property (pspec.get_name (), value);
 888         }
 889
 890         public new Value Json.Serializable.get_property (ParamSpec pspec) {
 891             Value val = Value(pspec.value_type);
 892             base.get_property (pspec.get_name (), ref val);
 893             return val;
 894         }
 895
 896         public unowned ParamSpec? find_property (string name) {
 897             return this.get_class ().find_property (name);
 898         }
 899
 900         public Json.Node serialize_property (string property_name, Value value, ParamSpec pspec) {
 901             if (property_name != "contents")
 902                 return default_serialize_property (property_name, value, pspec);
 903             var node = new Json.Node (Json.NodeType.ARRAY);
 904             node.init_array (new Json.Array ());
 905             var array = node.get_array ();
 906             foreach (var child in contents) {
 907                 if (child.language != null)
 908                     array.add_element (Json.gobject_serialize (child));
 909                 else
 910                     array.add_element (new Json.Node (Json.NodeType.VALUE).init_string (child.value));
 911             }
 912             return node;
 913         }
 914
 915         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node)
 916         {
 917             if (property_name == "contents") {
 918                 value = GLib.Value (typeof(Gee.ArrayList));
 919                         if (property_node.get_node_type () != Json.NodeType.ARRAY) {
 920                             warning ("unexpected property node type for 'arguments' %s", property_node.get_node_type ().to_string ());
 921                             return false;
 922                         }
 923                                 var contents = new Gee.ArrayList<MarkedString>();
 924
 925                         property_node.get_array ().foreach_element ((array, index, element) => {
 926                                 try {
 927                                                 var add = new MarkedString(
 928                                                         array.get_object_element(index).get_string_member("language"),
 929                                                         array.get_object_element(index).get_string_member("value")
 930                                                 );
 931
 932                                 contents.add ( add );
 933                             } catch (Error e) {
 934                                 warning ("argument %u to command could not be deserialized: %s", index, e.message);
 935                             }
 936                         });
 937                 value.set_object (contents);
 938                         return true;
 939             }
 940
 941             return default_deserialize_property (property_name, out value, pspec, property_node);
 942         }
 943     }
 944
 945     /**
 946      * A textual edit applicable to a text document.
 947      */
 948     public class TextEdit : Object {
 949         /**
 950          * The range of the text document to be manipulated. To insert
 951          * text into a document create a range where ``start === end``.
 952          */
 953         public Range range { get; set; }
 954
 955         /**
 956          * The string to be inserted. For delete operations use an
 957          * empty string.
 958          */
 959         public string newText { get; set; }
 960
 961         public TextEdit (Range range, string new_text = "") {
 962             this.range = range;
 963             this.newText = new_text;
 964         }
 965     }
 966
 967     /**
 968      * Describes textual changes on a single text document. The text document is
 969      * referred to as a {@link VersionedTextDocumentIdentifier} to allow clients to
 970      * check the text document version before an edit is applied. A
 971      * {@link TextDocumentEdit} describes all changes on a version ``Si`` and after they are
 972      * applied move the document to version ``Si+1``. So the creator of a
 973      * {@link TextDocumentEdit} doesn’t need to sort the array of edits or do any kind
 974      * of ordering. However the edits must be non overlapping.
 975      */
 976     public class TextDocumentEdit : Object, Json.Serializable {
 977         /**
 978          * The text document to change.
 979          */
 980         public VersionedTextDocumentIdentifier textDocument { get; set; }
 981
 982         /**
 983          * The edits to be applied.
 984          */
 985         public Gee.ArrayList<TextEdit> edits { get; set; default = new Gee.ArrayList<TextEdit> (); }
 986
 987         public TextDocumentEdit (VersionedTextDocumentIdentifier text_document) {
 988             this.textDocument = text_document;
 989         }
 990
 991         public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
 992             if (property_name != "edits")
 993                 return default_serialize_property (property_name, value, pspec);
 994
 995             var node = new Json.Node (Json.NodeType.ARRAY);
 996             node.init_array (new Json.Array ());
 997             var array = node.get_array ();
 998             foreach (var text_edit in edits) {
 999                 array.add_element (Json.gobject_serialize (text_edit));
1000             }
1001             return node;
1002         }
1003
1004         public bool deserialize_property (string property_name, out GLib.Value value, GLib.ParamSpec pspec, Json.Node property_node) {
1005             error ("deserialization not supported");
1006         }
1007     }
1008
1009     public abstract class CommandLike : Object, Json.Serializable {
1010         /**
1011          * The identifier of the actual command handler.
1012          */
1013         public string command { get; set; }
1014
1015         /**
1016          * Arguments that the command handler should be invoked with.
1017          */
1018         public Array<Variant>? arguments { get; set; }
1019
1020         public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1021             if (property_name != "arguments" || arguments == null)
1022                 return default_serialize_property (property_name, value, pspec);
1023
1024             var array = new Json.Array ();
1025             for (int i = 0; i < arguments.length; i++)
1026                 array.add_element (Json.gvariant_serialize (arguments.index (i)));
1027
1028             var node = new Json.Node (Json.NodeType.ARRAY);
1029             node.set_array (array);
1030             return node;
1031         }
1032
1033         public bool deserialize_property (string property_name, out GLib.Value value, GLib.ParamSpec pspec, Json.Node property_node)
1034         {
1035             if (property_name == "arguments") {
1036                 value = GLib.Value (typeof(Array));
1037                 if (property_node.get_node_type () != Json.NodeType.ARRAY) {
1038                     warning ("unexpected property node type for 'arguments' %s", property_node.get_node_type ().to_string ());
1039                     return false;
1040                 }
1041
1042                 var arguments = new Array<Variant> ();
1043
1044                 property_node.get_array ().foreach_element ((array, index, element) => {
1045                     try {
1046                         arguments.append_val (Json.gvariant_deserialize (element, null));
1047                     } catch (Error e) {
1048                         warning ("argument %u to command could not be deserialized: %s", index, e.message);
1049                     }
1050                 });
1051
1052                 value.set_boxed (arguments);
1053                 return true;
1054             } else if (property_name == "command") {
1055                 // workaround for json-glib < 1.5.2 (Ubuntu 20.04 / eOS 6)
1056                 if (property_node.get_value_type () != typeof (string)) {
1057                     value = "";
1058                     warning ("unexpected property node type for 'commands' %s", property_node.get_node_type ().to_string ());
1059                     return false;
1060                 }
1061
1062                 value = property_node.get_string ();
1063                 return true;
1064             } else {
1065                 return default_deserialize_property (property_name, out value, pspec, property_node);
1066             }
1067         }
1068     }
1069
1070     public class ExecuteCommandParams : CommandLike {
1071     }
1072
1073     /**
1074      * Represents a reference to a command. Provides a title which will be used
1075      * to represent a command in the UI. Commands are identified by a string
1076      * identifier. The recommended way to handle commands is to implement their
1077      * execution on the server side if the client and server provides the
1078      * corresponding capabilities. Alternatively the tool extension code could
1079      * handle the command. The protocol currently doesn’t specify a set of
1080      * well-known commands.
1081      */
1082     public class Command : CommandLike {
1083         /**
1084          * The title of the command, like `save`.
1085          */
1086         public string title { get; set; }
1087     }
1088
1089     /**
1090      * A code lens represents a command that should be shown along with
1091      * source text, like the number of references, a way to run tests, etc.
1092      *
1093      * A code lens is _unresolved_ when no command is associated to it. For
1094      * performance reasons the creation of a code lens and resolving should be done
1095      * in two stages.
1096      */
1097     public class CodeLens : Object {
1098         /**
1099          * The range in which this code lens is valid. Should only span a single
1100          * line.
1101          */
1102         public Range range { get; set; }
1103
1104         /**
1105          * The command this code lens represents.
1106          */
1107         public Command? command { get; set; }
1108     }
1109
1110     public class DocumentRangeFormattingParams : Object {
1111         public TextDocumentIdentifier textDocument { get; set; }
1112         public Range? range { get; set; }
1113         public FormattingOptions options { get; set; }
1114     }
1115
1116     public class FormattingOptions : Object {
1117         public uint tabSize { get; set; }
1118         public bool insertSpaces { get; set; }
1119         public bool trimTrailingWhitespace { get; set; }
1120         public bool insertFinalNewline { get; set; }
1121         public bool trimFinalNewlines { get; set; }
1122     }
1123
1124     public class CodeActionParams : Object {
1125         public TextDocumentIdentifier textDocument { get; set; }
1126         public Range range { get; set; }
1127         public CodeActionContext context { get; set; }
1128     }
1129
1130
1131     public class CodeActionContext : Object, Json.Serializable {
1132         public Gee.List<Diagnostic> diagnostics { get; set; default = new Gee.ArrayList<Diagnostic> (); }
1133         public string[]? only { get; set; }
1134 /*
1135         public bool deserialize_property (string property_name, out Value value, ParamSpec pspec, Json.Node property_node) {
1136             if (property_name != "diagnostics")
1137                 return default_deserialize_property (property_name, out value, pspec, property_node);
1138             var diags = new Gee.ArrayList<Diagnostic> ();
1139             property_node.get_array ().foreach_element ((array, index, element) => {
1140                 try {
1141                     diags.add (Vls.Util.parse_variant<Diagnostic> (Json.gvariant_deserialize (element, null)));
1142                 } catch (Error e) {
1143                     warning ("argument %u could not be deserialized: %s", index, e.message);
1144                 }
1145             });
1146             value = diags;
1147             return true;
1148         }
1149         */
1150     }
1151
1152
1153         public class Diagnostics : Object, Json.Serializable
1154         {
1155                 public Diagnostics()
1156                 {
1157                         this.diagnostics = new Gee.ArrayList<Diagnostic>((a,b) => {
1158                                 return a.equals(b);
1159                         });
1160                 }
1161
1162                 public string uri { get; set; }
1163
1164                 public int version  { get; set; default = 0; }
1165         public Gee.ArrayList<Diagnostic>? diagnostics { get; set; }
1166
1167                 public string filename {
1168                         owned get {
1169                                 return File.new_for_uri (this.uri).get_path();
1170                         }
1171                         private set {}
1172                 }
1173
1174                 public bool deserialize_property (string property_name, out GLib.Value val, GLib.ParamSpec pspec, Json.Node property_node) {
1175                         if (property_name == "diagnostics") {
1176                 val = GLib.Value (typeof(Gee.ArrayList));
1177                                 var diags =  new Gee.ArrayList<Diagnostic> ((a,b) => {
1178                                         return a.equals(b);
1179                                 });
1180                                 if (property_node.get_node_type () != Json.NodeType.ARRAY) {
1181                                         val.set_object(diags);
1182                                         warning ("unexpected property node type for 'arguments' %s", property_node.get_node_type ().to_string ());
1183                                         return false;
1184                                 }
1185
1186
1187
1188                                 property_node.get_array ().foreach_element ((array, index, element) => {
1189
1190                                                 diags.add (Json.gobject_deserialize (typeof (Lsp.Diagnostic), element) as Diagnostic );
1191
1192                                                 //warning ("argument %u to command could not be deserialized: %s", index, e.message);
1193
1194                                 });
1195                                 val.set_object(diags);
1196
1197                                 return true;
1198                         }
1199
1200                         return default_deserialize_property (property_name, out val, pspec, property_node);
1201
1202                 }
1203
1204
1205         }
1206
1207
1208    public  class CodeAction : Object, Json.Serializable {
1209         public string title { get; set; }
1210         public string? kind { get; set; }
1211         public Gee.Collection<Diagnostic>? diagnostics { get; set; }
1212         public bool isPreferred { get; set; }
1213         public WorkspaceEdit? edit { get; set; }
1214         public Command? command { get; set; }
1215         public Object? data { get; set; }
1216
1217         protected void add_diagnostic (Diagnostic diag) {
1218             if (diagnostics == null)
1219                 diagnostics = new Gee.ArrayList<Diagnostic> ();
1220             diagnostics.add (diag);
1221         }
1222
1223         public override Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1224             if (property_name != "diagnostics")
1225                 return default_serialize_property (property_name, value, pspec);
1226
1227             var array = new Json.Array ();
1228             if (diagnostics != null)
1229                 foreach (var text_edit in diagnostics)
1230                     array.add_element (Json.gobject_serialize (text_edit));
1231             return new Json.Node.alloc ().init_array (array);
1232         }
1233     }
1234
1235     public class WorkspaceEdit : Object, Json.Serializable {
1236         public Gee.List<TextDocumentEdit>? documentChanges { get; set; }
1237
1238         public Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1239             if (property_name != "documentChanges")
1240                 return default_serialize_property (property_name, value, pspec);
1241
1242             var node = new Json.Node (Json.NodeType.ARRAY);
1243             node.init_array (new Json.Array ());
1244             if (documentChanges != null) {
1245                 var array = node.get_array ();
1246                 foreach (var text_edit in documentChanges) {
1247                     array.add_element (Json.gobject_serialize (text_edit));
1248                 }
1249             }
1250             return node;
1251         }
1252     }
1253
1254     [Flags]
1255     public enum SymbolTags {
1256         NONE,
1257         DEPRECATED
1258     }
1259
1260     public class CallHierarchyItem : Object, Json.Serializable {
1261         public string name { get; set; }
1262         public SymbolKind kind { get; set; }
1263         public SymbolTags tags { get; set; }
1264         public string? detail { get; set; }
1265         public string uri { get; set; }
1266         public Range range { get; set; }
1267         public Range selectionRange { get; set; }
1268
1269         public override Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1270             if (property_name != "tags")
1271                 return default_serialize_property (property_name, value, pspec);
1272             var array = new Json.Array ();
1273             if (SymbolTags.DEPRECATED in tags)
1274                 array.add_int_element (SymbolTags.DEPRECATED);
1275             return new Json.Node.alloc ().init_array (array);
1276         }
1277 /*
1278         public CallHierarchyItem.from_symbol (Vala.Symbol symbol) {
1279             this.name = symbol.get_full_name ();
1280             if (symbol is Vala.Method) {
1281                 if (symbol.parent_symbol is Vala.Namespace)
1282                     this.kind = SymbolKind.Function;
1283                 else
1284                     this.kind = SymbolKind.Method;
1285             } else if (symbol is Vala.Signal) {
1286                 this.kind = SymbolKind.Event;
1287             } else if (symbol is Vala.Constructor) {
1288                 this.kind = SymbolKind.Constructor;
1289             } else {
1290                 this.kind = SymbolKind.Method;
1291             }
1292             var version = symbol.get_attribute ("Version");
1293             if (version != null && (version.get_bool ("deprecated") || version.get_string ("deprecated_since") != null)) {
1294                 this.tags |= SymbolTags.DEPRECATED;
1295             }
1296             this.detail = Vls.CodeHelp.get_symbol_representation (null, symbol, null, true);
1297             this.uri = File.new_for_commandline_arg (symbol.source_reference.file.filename).get_uri ();
1298             this.range = new Range.from_sourceref (symbol.source_reference);
1299             if (symbol.comment != null)
1300                 this.range = new Range.from_sourceref (symbol.comment.source_reference).union (this.range);
1301             if (symbol is Vala.Subroutine && ((Vala.Subroutine)symbol).body != null)
1302                 this.range = new Range.from_sourceref (((Vala.Subroutine)symbol).body.source_reference).union (this.range);
1303             this.selectionRange = new Range.from_sourceref (symbol.source_reference);
1304         }
1305         */
1306     }
1307
1308     public class CallHierarchyIncomingCall : Json.Serializable, Object {
1309         /**
1310          * The method that calls the query method.
1311          */
1312         public CallHierarchyItem from { get; set; }
1313
1314         /**
1315          * The ranges at which the query method is called by `from`.
1316          */
1317         public Gee.ArrayList<Range> fromRanges { get; set; default = new Gee.ArrayList<Range> (); }
1318
1319         public override Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1320             if (property_name == "from")
1321                 return default_serialize_property (property_name, value, pspec);
1322             var array = new Json.Array ();
1323             foreach (var range in fromRanges)
1324                 array.add_element (Json.gobject_serialize (range));
1325             return new Json.Node.alloc ().init_array (array);
1326         }
1327     }
1328
1329     public class CallHierarchyOutgoingCall : Json.Serializable, Object {
1330         /**
1331          * The method that the query method calls.
1332          */
1333         public CallHierarchyItem to { get; set; }
1334
1335         /**
1336          * The ranges at which the method is called by the query method.
1337          */
1338         public Gee.ArrayList<Range> fromRanges { get; set; default = new Gee.ArrayList<Range> (); }
1339
1340         public override Json.Node serialize_property (string property_name, GLib.Value value, GLib.ParamSpec pspec) {
1341             if (property_name == "to")
1342                 return default_serialize_property (property_name, value, pspec);
1343             var array = new Json.Array ();
1344             foreach (var range in fromRanges)
1345                 array.add_element (Json.gobject_serialize (range));
1346             return new Json.Node.alloc ().init_array (array);
1347         }
1348     }
1349
1350     public class InlayHintParams : Json.Serializable, Object {
1351         public TextDocumentIdentifier textDocument { get; set; }
1352         public Range range { get; set; }
1353     }
1354
1355     public enum InlayHintKind {
1356         UNSET,
1357         TYPE,
1358         PARAMETER
1359     }
1360
1361     public class InlayHint : Object {
1362         public Position position { get; set; }
1363         public string label { get; set; }
1364         public InlayHintKind kind { get; set; }
1365         public string? tooltip { get; set; }
1366         public bool paddingLeft { get; set; }
1367         public bool paddingRight { get; set; }
1368     }
1369
1370    public  class TypeHierarchyItem : Object, Json.Serializable {
1371         /**
1372          * The name of this item
1373          */
1374         public string name { get; set; }
1375
1376         /**
1377          * The kind of this item
1378          */
1379         public SymbolKind kind { get; set; }
1380
1381         /**
1382          * Tags for this item
1383          */
1384         public SymbolTags tags { get; set; }
1385
1386         /**
1387          * More detail for this item, e.g. the signature of a function.
1388          */
1389         public string? detail { get; set; }
1390
1391         /**
1392          * The resource identifier of this item.
1393          */
1394         public string uri { get; set; }
1395
1396         /**
1397          * The range enclosing this symbol not including leading/trailing
1398          * whitespace, but everything else, e.g. comments and code.
1399          */
1400         public Range range { get; set; }
1401
1402         /**
1403          * The range that should be selected and revealed when this symbol
1404          * is being picked, e.g. the name of a function. Must be contained
1405          * by {@link TypeHierarchyItem.range}
1406          */
1407         public Range selectionRange { get; set; }
1408
1409         private TypeHierarchyItem () {}
1410 /*
1411         public TypeHierarchyItem.from_symbol (Vala.TypeSymbol symbol) {
1412             this.name = symbol.get_full_name ();
1413             if (symbol is Vala.Class)
1414                 this.kind = SymbolKind.Class;
1415             else if (symbol is Vala.Delegate)
1416                 this.kind = SymbolKind.Interface;
1417             else if (symbol is Vala.Enum)
1418                 this.kind = SymbolKind.Enum;
1419             else if (symbol is Vala.ErrorCode)
1420                 this.kind = SymbolKind.EnumMember;
1421             else if (symbol is Vala.ErrorDomain)
1422                 this.kind = SymbolKind.Enum;
1423             else if (symbol is Vala.Interface)
1424                 this.kind = SymbolKind.Interface;
1425             else if (symbol is Vala.Struct)
1426                 this.kind = SymbolKind.Struct;
1427             else if (symbol is Vala.TypeParameter)
1428                 this.kind = SymbolKind.TypeParameter;
1429             else {
1430                 this.kind = SymbolKind.Module;
1431                 warning ("unexpected symbol kind in type hierarchy: `%s'", symbol.type_name);
1432             }
1433
1434             var version = symbol.get_attribute ("Version");
1435             if (version != null && (version.get_bool ("deprecated") || version.get_string ("deprecated_since") != null)) {
1436                 this.tags |= SymbolTags.DEPRECATED;
1437             }
1438             this.detail = Vls.CodeHelp.get_symbol_representation (null, symbol, null, true);
1439             this.uri = File.new_for_commandline_arg (symbol.source_reference.file.filename).get_uri ();
1440             this.range = new Range.from_sourceref (symbol.source_reference);
1441             this.selectionRange = this.range;
1442
1443             // widen range to include all members
1444             if (symbol is Vala.ObjectTypeSymbol) {
1445                 foreach (var member in ((Vala.ObjectTypeSymbol)symbol).get_members ()) {
1446                     if (member.source_reference != null)
1447                         this.range = this.range.union (new Range.from_sourceref (member.source_reference));
1448                 }
1449             } else if (symbol is Vala.Enum) {
1450                 foreach (var member in ((Vala.Enum)symbol).get_values ()) {
1451                     if (member.source_reference != null)
1452                         this.range = this.range.union (new Range.from_sourceref (member.source_reference));
1453                 }
1454                 foreach (var method in ((Vala.Enum)symbol).get_methods ()) {
1455                     if (method.source_reference != null)
1456                         this.range = this.range.union (new Range.from_sourceref (method.source_reference));
1457                 }
1458             } else if (symbol is Vala.ErrorDomain) {
1459                 foreach (var member in ((Vala.ErrorDomain)symbol).get_codes ()) {
1460                     if (member.source_reference != null)
1461                         this.range = this.range.union (new Range.from_sourceref (member.source_reference));
1462                 }
1463                 foreach (var method in ((Vala.ErrorDomain)symbol).get_methods ()) {
1464                     if (method.source_reference != null)
1465                         this.range = this.range.union (new Range.from_sourceref (method.source_reference));
1466                 }
1467             } else if (symbol is Vala.Struct) {
1468                 foreach (var field in ((Vala.Struct)symbol).get_fields ()) {
1469                     if (field.source_reference != null)
1470                         this.range = this.range.union (new Range.from_sourceref (field.source_reference));
1471                 }
1472                 foreach (var method in ((Vala.Struct)symbol).get_methods ()) {
1473                     if (method.source_reference != null)
1474                         this.range = this.range.union (new Range.from_sourceref (method.source_reference));
1475                 }
1476             }
1477         }
1478         */
1479     }
1480 }