Java 类org.eclipse.lsp4j.SymbolKind 实例源码

protected SymbolInformation createSymbol(final EObject object) {
  final String name = this.getSymbolName(object);
  if ((name == null)) {
    return null;
  }
  final SymbolKind kind = this.getSymbolKind(object);
  if ((kind == null)) {
    return null;
  }
  final Location location = this.getSymbolLocation(object);
  if ((location == null)) {
    return null;
  }
  final SymbolInformation symbol = new SymbolInformation();
  symbol.setName(name);
  symbol.setKind(kind);
  symbol.setLocation(location);
  return symbol;
}

@Inject
public SymbolKindHelper(LanguageServerResources resources) {
  this.resources = resources;
  // TODO Replace markWarning() image with proper images
  iconMap.put(SymbolKind.Method, resources.methodItem());
  iconMap.put(SymbolKind.Function, resources.textItem());
  iconMap.put(SymbolKind.Constructor, resources.textItem());
  iconMap.put(SymbolKind.Variable, resources.variableItem());
  iconMap.put(SymbolKind.Class, resources.classItem());
  iconMap.put(SymbolKind.Interface, resources.interfaceItem());
  iconMap.put(SymbolKind.Namespace, resources.textItem());
  iconMap.put(SymbolKind.Package, resources.textItem());
  iconMap.put(SymbolKind.Module, resources.moduleItem());
  iconMap.put(SymbolKind.Property, resources.propertyItem());
  iconMap.put(SymbolKind.Enum, resources.enumItem());
  iconMap.put(SymbolKind.String, resources.textItem());
  iconMap.put(SymbolKind.File, resources.textItem());
  iconMap.put(SymbolKind.Array, resources.textItem());
  iconMap.put(SymbolKind.Number, resources.textItem());
  iconMap.put(SymbolKind.Boolean, resources.textItem());
  iconMap.put(SymbolKind.Field, resources.fieldItem());
  iconMap.put(SymbolKind.Constant, resources.textItem());
}

private static SymbolInformation getSymbolInfo(final SInvokable m) {
  SymbolInformation sym = new SymbolInformation();
  sym.setName(m.getSignature().toString());
  sym.setKind(SymbolKind.Method);
  if (null != m.getSourceSection()) {
    sym.setLocation(getLocation(m.getSourceSection()));
  }
  if (m.getHolderUnsafe() != null) {
    sym.setContainerName(m.getHolder().getName().getString());
  }
  return sym;
}

private static SymbolInformation getSymbolInfo(final SlotDefinition d,
    final MixinDefinition m) {
  SymbolInformation sym = new SymbolInformation();
  sym.setName(d.getName().getString());
  SymbolKind kind = m.isModule() ? SymbolKind.Constant
      : SymbolKind.Property;
  sym.setKind(kind);
  sym.setLocation(getLocation(d.getSourceSection()));
  sym.setContainerName(m.getName().getString());
  return sym;
}

private static SymbolInformation getSymbolInfo(final MixinDefinition m) {
  SymbolInformation sym = new SymbolInformation();
  sym.setName(m.getName().getString());
  SymbolKind kind = m.isModule() ? SymbolKind.Module
      : SymbolKind.Class;
  sym.setKind(kind);
  sym.setLocation(getLocation(m.getSourceSection()));

  MixinDefinition outer = m.getOuterMixinDefinition();
  if (outer != null) {
    sym.setContainerName(outer.getName().getString());
  }
  return sym;
}

public static SymbolKind mapKind(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.ANNOTATION:
        return SymbolKind.Property; // TODO: find a better mapping
    case IJavaElement.CLASS_FILE:
    case IJavaElement.COMPILATION_UNIT:
        return SymbolKind.File;
    case IJavaElement.FIELD:
        return SymbolKind.Field;
    case IJavaElement.IMPORT_CONTAINER:
    case IJavaElement.IMPORT_DECLARATION:
        return SymbolKind.Module;
    case IJavaElement.INITIALIZER:
        return SymbolKind.Constructor;
    case IJavaElement.LOCAL_VARIABLE:
    case IJavaElement.TYPE_PARAMETER:
        return SymbolKind.Variable;
    case IJavaElement.METHOD:
        return SymbolKind.Method;
    case IJavaElement.PACKAGE_DECLARATION:
        return SymbolKind.Package;
    case IJavaElement.TYPE:
        try {
            return ( ((IType)element).isInterface() ? SymbolKind.Interface : SymbolKind.Class);
        } catch (JavaModelException e) {
            return SymbolKind.Class;
        }
    }
    return SymbolKind.String;
}

@Test
public void testProjectSearch() {
    String query = "IFoo";
    List<SymbolInformation> results = handler.search(query, monitor);
    assertNotNull(results);
    assertEquals("Found "+ results.size() + " results", 1, results.size());
    SymbolInformation symbol = results.get(0);
    assertEquals(SymbolKind.Interface, symbol.getKind());
    assertEquals("java", symbol.getContainerName());
    assertEquals(query, symbol.getName());
    Location location = symbol.getLocation();
    assertEquals(JDTUtils.newRange(), location.getRange());
    assertTrue("Unexpected uri "+ location.getUri(), location.getUri().endsWith("Foo.java"));
}

@Test
public void testTypes() throws Exception {
    String className = "org.sample.Bar";
    List<? extends SymbolInformation> symbols = getSymbols(className);
    assertHasSymbol("Bar", "Bar.java", SymbolKind.Class, symbols);
    assertHasSymbol("main(String[])", "Bar", SymbolKind.Method, symbols);
    assertHasSymbol("MyInterface", "Bar", SymbolKind.Interface, symbols);
    assertHasSymbol("foo()", "MyInterface", SymbolKind.Method, symbols);
    assertHasSymbol("MyClass", "Bar", SymbolKind.Class, symbols);
    assertHasSymbol("bar()", "MyClass", SymbolKind.Method, symbols);

}

private void assertHasSymbol(String expectedType, String expectedParent, SymbolKind expectedKind, Collection<? extends SymbolInformation> symbols) {
    Optional<? extends SymbolInformation> symbol = symbols.stream()
                                                         .filter(s -> expectedType.equals(s.getName()) && expectedParent.equals(s.getContainerName()))
                                                         .findFirst();
    assertTrue(expectedType + "(" + expectedParent + ")" + " is missing from " + symbols, symbol.isPresent());
    assertKind(expectedKind, symbol.get());
}

protected void createSymbol(final IEObjectDescription description, final IReferenceFinder.IResourceAccess resourceAccess, final Procedure1<? super SymbolInformation> acceptor) {
  final String name = this.getSymbolName(description);
  if ((name == null)) {
    return;
  }
  final SymbolKind kind = this.getSymbolKind(description);
  if ((kind == null)) {
    return;
  }
  final Procedure1<Location> _function = (Location location) -> {
    final SymbolInformation symbol = new SymbolInformation(name, kind, location);
    acceptor.apply(symbol);
  };
  this.getSymbolLocation(description, resourceAccess, _function);
}

protected SymbolInformation createSymbol(final IEObjectDescription description) {
  final String symbolName = this.getSymbolName(description);
  if ((symbolName == null)) {
    return null;
  }
  final SymbolKind symbolKind = this.getSymbolKind(description);
  if ((symbolKind == null)) {
    return null;
  }
  final SymbolInformation symbol = new SymbolInformation();
  symbol.setName(symbolName);
  symbol.setKind(symbolKind);
  return symbol;
}

public String from(SymbolKind kind) {
  switch (kind) {
    case Method:
      return "method";
    case Function:
      return "function";
    case Constructor:
      return "constructor";
    case Variable:
      return "variable";
    case Class:
      return "class";
    case Interface:
      return "interface";
    case Namespace:
      return "namespace";
    case Package:
      return "package";
    case Module:
      return "module";
    case Property:
      return "property";
    case Enum:
      return "enum";
    case String:
      return "string";
    case File:
      return "file";
    case Array:
      return "array";
    case Number:
      return "number";
    case Boolean:
      return "boolean";
    default:
      return "property";
  }
}

public SymbolInformation(@NonNull final String name, @NonNull final SymbolKind kind, @NonNull final Location location) {
  this.name = name;
  this.kind = kind;
  this.location = location;
}

public SymbolInformation(@NonNull final String name, @NonNull final SymbolKind kind, @NonNull final Location location, final String containerName) {
  this.name = name;
  this.kind = kind;
  this.location = location;
  this.containerName = containerName;
}

/**
 * The kind of this symbol.
 */
@Pure
@NonNull
public SymbolKind getKind() {
  return this.kind;
}

/**
 * The kind of this symbol.
 */
public void setKind(@NonNull final SymbolKind kind) {
  this.kind = kind;
}

private void assertKind(SymbolKind expectedKind, SymbolInformation symbol) {
    assertSame("Unexpected SymbolKind in " + symbol.getName(), expectedKind, symbol.getKind());
}

protected SymbolKind getSymbolKind(final EObject object) {
  return this.getSymbolKind(object.eClass());
}

protected SymbolKind getSymbolKind(final IEObjectDescription description) {
  return this.getSymbolKind(description.getEClass());
}

protected SymbolKind getSymbolKind(final EClass type) {
  return SymbolKind.Property;
}

public SymbolInformation(@NonNull final String name, @NonNull final SymbolKind kind, @NonNull final Location location) {
  this.name = name;
  this.kind = kind;
  this.location = location;
}

public SymbolInformation(@NonNull final String name, @NonNull final SymbolKind kind, @NonNull final Location location, final String containerName) {
  this.name = name;
  this.kind = kind;
  this.location = location;
  this.containerName = containerName;
}

/**
 * The kind of this symbol.
 */
@Pure
@NonNull
public SymbolKind getKind() {
  return this.kind;
}

/**
 * The kind of this symbol.
 */
public void setKind(@NonNull final SymbolKind kind) {
  this.kind = kind;
}

public SVGResource getIcon(SymbolKind kind) {
  if (iconMap.containsKey(kind)) {
    return iconMap.get(kind);
  }
  return null;
}