Properly implement document/documentSymbol

When I re-wrote the language feature implementations in #166, I
refactored documentSymbol. But it mostly just copied the previous
implementation, which produced a flat list of symbols. This meant that
member symbols would appear at the top-level, but documentSymbol is
meant to provide a tree-like view, where symbols can have children. So
this commit re-writes documentSymbol to produce a list of only the
top-level shapes' symbols (and the namespace statement's symbol), with
members' symbols being added as children to the top-level symbols, and
members of inline i/o are children of the inline i/o symbol.

I also changed up the Symbol kind a bit, so root shapes are of type
`Class` (except enum/intEnum, which are of type `Enum`), members are
of type `Field` (except enum/intEnum members, which are of type
`EnumMember`), and service/resource/operation members are of type
`Property`.

I explored having different symbol kinds for different types of shapes,
like making service-type shapes be of kind `Interface`, and primitive
types being of their corresponding kind (for example, an integer shape
would have kind `Number`), but I wasn't sure what some shape types
should be. For example, what should a `blob` shape be? So I decided to
just make all top-level shapes just be of kind `Class`.

I also fixed the range and selection range of symbols. Range now covers
everything from shape type -> end of block (if applicable), and
selection range is just the shape/member name.

I considered adding more children for service-type shape members,
like making the `operations` child symbol of a service shape have a
child for each of the operations in the list, but I think it would make
the tree view more noisy, plus I think the intent is to show symbol
definitions.

I also made a minor adjustment to the parsing of operations members,
making them always be inline or node member defs, instead of possibly a
regular member def for non-inline i/o. This is consistent with
resource/service members, which are always node members.

Author: milesziemer

src/main/java/software/amazon/smithy/lsp/language/DocumentSymbolHandler.java

@@ -5,59 +5,210 @@
 
 package software.amazon.smithy.lsp.language;
 
+import static software.amazon.smithy.lsp.protocol.LspAdapter.identRange;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.function.Consumer;
 import org.eclipse.lsp4j.DocumentSymbol;
-import org.eclipse.lsp4j.Range;
 import org.eclipse.lsp4j.SymbolInformation;
 import org.eclipse.lsp4j.SymbolKind;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import software.amazon.smithy.lsp.document.Document;
-import software.amazon.smithy.lsp.protocol.LspAdapter;
 import software.amazon.smithy.lsp.syntax.Syntax;
 
 public record DocumentSymbolHandler(Document document, List<Syntax.Statement> statements) {
+    // Statement types that may appear before the start of a shape's members, which
+    // we need to skip.
+    private static final EnumSet<Syntax.Statement.Type> BEFORE_MEMBER_TYPES = EnumSet.of(
+            Syntax.Statement.Type.ForResource,
+            Syntax.Statement.Type.Mixins,
+            Syntax.Statement.Type.Block
+    );
+
     /**
      * @return A list of DocumentSymbol
      */
     public List<Either<SymbolInformation, DocumentSymbol>> handle() {
-        return statements.stream()
-                .mapMulti(this::addSymbols)
-                .toList();
+        List<Either<SymbolInformation, DocumentSymbol>> result = new ArrayList<>();
+        // Passing around the list would make the code super noisy, and we'd have
+        // to do Either.forRight everywhere, so use a consumer.
+        addSymbols((symbol) -> result.add(Either.forRight(symbol)));
+        return result;
     }
 
-    private void addSymbols(Syntax.Statement statement, Consumer<Either<SymbolInformation, DocumentSymbol>> consumer) {
-        switch (statement) {
-            case Syntax.Statement.TraitApplication app -> addSymbol(consumer, app.id(), SymbolKind.Class);
+    private void addSymbols(Consumer<DocumentSymbol> consumer) {
+        var listIterator = statements.listIterator();
+        while (listIterator.hasNext()) {
+            var statement = listIterator.next();
+            if (statement instanceof Syntax.Statement.Namespace namespace) {
+                consumer.accept(namespaceSymbol(namespace));
+            } else if (statement instanceof Syntax.Statement.ShapeDef shapeDef) {
+                var symbol = rootSymbol(shapeDef);
+                consumer.accept(symbol);
+                addMemberSymbols(listIterator, symbol);
+            }
+        }
+    }
 
-            case Syntax.Statement.ShapeDef def -> addSymbol(consumer, def.shapeName(), SymbolKind.Class);
+    private void addMemberSymbols(ListIterator<Syntax.Statement> listIterator, DocumentSymbol parent) {
+        // We only want to collect members within the block, so we can use Block's lastMemberIndex
+        // to tell us when to stop.
+        int lastMemberIndex = 0;
+        while (listIterator.hasNext()) {
+            var statement = listIterator.next();
 
-            case Syntax.Statement.EnumMemberDef def -> addSymbol(consumer, def.name(), SymbolKind.Enum);
+            if (!BEFORE_MEMBER_TYPES.contains(statement.type())) {
+                // No members
+                listIterator.previous();
+                return;
+            }
 
-            case Syntax.Statement.ElidedMemberDef def -> addSymbol(consumer, def.name(), SymbolKind.Property);
+            if (statement instanceof Syntax.Statement.Block block) {
+                // Update the parent's range to cover all its members
+                var blockEnd = document.positionAtIndex(block.end());
+                parent.getRange().setEnd(blockEnd);
+                lastMemberIndex = block.lastStatementIndex();
+                break;
+            }
+        }
+
+        List<DocumentSymbol> children = new ArrayList<>();
 
-            case Syntax.Statement.MemberDef def -> {
-                addSymbol(consumer, def.name(), SymbolKind.Property);
-                if (def.target() != null) {
-                    addSymbol(consumer, def.target(), SymbolKind.Class);
+        while (listIterator.nextIndex() <= lastMemberIndex) {
+            var statement = listIterator.next();
+
+            switch (statement) {
+                case Syntax.Statement.MemberDef memberDef -> {
+                    children.add(memberDefSymbol(memberDef));
+                }
+
+                case Syntax.Statement.EnumMemberDef enumMemberDef -> {
+                    children.add(enumMemberDefSymbol(enumMemberDef));
+                }
+
+                case Syntax.Statement.ElidedMemberDef elidedMemberDef -> {
+                    children.add(elidedMemberDefSymbol(elidedMemberDef));
+                }
+
+                case Syntax.Statement.NodeMemberDef nodeMemberDef -> {
+                    children.add(nodeMemberDefSymbol(nodeMemberDef));
+                }
+
+                case Syntax.Statement.InlineMemberDef inlineMemberDef -> {
+                    children.add(inlineMemberSymbol(listIterator, inlineMemberDef));
+                }
+
+                default -> {
                 }
-            }
-            default -> {
             }
         }
+
+        if (!children.isEmpty()) {
+            parent.setChildren(children);
+        }
     }
 
-    private void addSymbol(
-            Consumer<Either<SymbolInformation, DocumentSymbol>> consumer,
-            Syntax.Ident ident,
-            SymbolKind symbolKind
-    ) {
-        Range range = LspAdapter.identRange(ident, document);
-        if (range == null) {
-            return;
+    private DocumentSymbol namespaceSymbol(Syntax.Statement.Namespace namespace) {
+        var range = document.rangeBetween(namespace.start(), namespace.end());
+        var selectionRange = identRange(namespace.namespace(), document);
+        return new DocumentSymbol(
+                namespace.namespace().stringValue(),
+                SymbolKind.Namespace,
+                range,
+                selectionRange
+        );
+    }
+
+    private DocumentSymbol rootSymbol(Syntax.Statement.ShapeDef shapeDef) {
+        var symbolKind = getSymbolKind(shapeDef);
+        var range = document.rangeBetween(shapeDef.start(), shapeDef.end());
+        var selectionRange = identRange(shapeDef.shapeName(), document);
+        return new DocumentSymbol(
+                shapeDef.shapeName().stringValue(),
+                symbolKind,
+                range,
+                selectionRange
+        );
+    }
+
+    private static SymbolKind getSymbolKind(Syntax.Statement.ShapeDef shapeDef) {
+        return switch (shapeDef.shapeType().stringValue()) {
+            case "enum", "intEnum" -> SymbolKind.Enum;
+            default -> SymbolKind.Class;
+        };
+    }
+
+    private DocumentSymbol memberDefSymbol(Syntax.Statement.MemberDef memberDef) {
+        var range = document.rangeBetween(memberDef.start(), memberDef.end());
+        var selectionRange = identRange(memberDef.name(), document);
+        var detail = memberDef.target() == null
+                ? null
+                : memberDef.target().stringValue();
+
+        return new DocumentSymbol(
+                memberDef.name().stringValue(),
+                SymbolKind.Field,
+                range,
+                selectionRange,
+                detail
+        );
+    }
+
+    private DocumentSymbol enumMemberDefSymbol(Syntax.Statement.EnumMemberDef enumMemberDef) {
+        var range = document.rangeBetween(enumMemberDef.start(), enumMemberDef.end());
+        var selectionRange = identRange(enumMemberDef.name(), document);
+        return new DocumentSymbol(
+                enumMemberDef.name().stringValue(),
+                SymbolKind.EnumMember,
+                range,
+                selectionRange
+        );
+    }
+
+    private DocumentSymbol elidedMemberDefSymbol(Syntax.Statement.ElidedMemberDef elidedMemberDef) {
+        var range = document.rangeBetween(elidedMemberDef.start(), elidedMemberDef.end());
+        return new DocumentSymbol(
+                "$" + elidedMemberDef.name().stringValue(),
+                SymbolKind.Field,
+                range,
+                range
+        );
+    }
+
+    private DocumentSymbol nodeMemberDefSymbol(Syntax.Statement.NodeMemberDef nodeMemberDef) {
+        var range = document.rangeBetween(nodeMemberDef.start(), nodeMemberDef.end());
+        var selectionRange = identRange(nodeMemberDef.name(), document);
+        String detail = null;
+        if (nodeMemberDef.value() instanceof Syntax.Ident ident) {
+            detail = ident.stringValue();
         }
 
-        DocumentSymbol symbol = new DocumentSymbol(ident.stringValue(), symbolKind, range, range);
-        consumer.accept(Either.forRight(symbol));
+        return new DocumentSymbol(
+                nodeMemberDef.name().stringValue(),
+                SymbolKind.Property,
+                range,
+                selectionRange,
+                detail
+        );
+    }
+
+    private DocumentSymbol inlineMemberSymbol(
+            ListIterator<Syntax.Statement> listIterator,
+            Syntax.Statement.InlineMemberDef inlineMemberDef
+    ) {
+        var range = document.rangeBetween(inlineMemberDef.start(), inlineMemberDef.end());
+        var selectionRange = identRange(inlineMemberDef.name(), document);
+        var inlineSymbol = new DocumentSymbol(
+                inlineMemberDef.name().stringValue(),
+                SymbolKind.Property,
+                range,
+                selectionRange
+        );
+
+        addMemberSymbols(listIterator, inlineSymbol);
+        return inlineSymbol;
     }
 }

src/main/java/software/amazon/smithy/lsp/syntax/Parser.java

@@ -642,21 +642,12 @@ private void operationMembers(Syntax.Statement.Block parent) {
 
             ws();
 
-            if (isIdentStart()) {
-                var opMemberDef = new Syntax.Statement.MemberDef(parent, memberName);
-                opMemberDef.start = opMemberStart;
-                opMemberDef.colonPos = colonPos;
-                opMemberDef.target = ident();
-                setEnd(opMemberDef);
-                addStatement(opMemberDef);
-            } else {
-                var nodeMemberDef = new Syntax.Statement.NodeMemberDef(parent, memberName);
-                nodeMemberDef.start = opMemberStart;
-                nodeMemberDef.colonPos = colonPos;
-                nodeMemberDef.value = parseNode();
-                setEnd(nodeMemberDef);
-                addStatement(nodeMemberDef);
-            }
+            var nodeMemberDef = new Syntax.Statement.NodeMemberDef(parent, memberName);
+            nodeMemberDef.start = opMemberStart;
+            nodeMemberDef.colonPos = colonPos;
+            nodeMemberDef.value = parseNode();
+            setEnd(nodeMemberDef);
+            addStatement(nodeMemberDef);
 
             ws();
         }