import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
	sendLogMessageNotification(MessageType.Info, "Initializing capabilities of the server...");
	Integer processId = params.getProcessId();
	if(processId != null) {
		setParentProcessId(processId.longValue());
	} else {
		sendLogMessageNotification(MessageType.Info, "Missing Parent process ID!!");
		setParentProcessId(0);
	}
	
	InitializeResult result = new InitializeResult();
	
	ServerCapabilities capabilities = new ServerCapabilities();
	capabilities.setTextDocumentSync(TextDocumentSyncKind.Full);
	capabilities.setCompletionProvider(new CompletionOptions(Boolean.TRUE, Arrays.asList(".","?","&", "\"", "=")));
	capabilities.setHoverProvider(Boolean.TRUE);
	
	result.setCapabilities(capabilities);
	return CompletableFuture.completedFuture(result);
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
public TextDocumentSynchronize getSynchronize(TextDocumentSyncKind kind) {
  if (kind == null) {
    // use NONE syncronizer if server doesn't require any
    return NONE;
  }
  switch (kind) {
    case None:
      return NONE;
    case Full:
      return fullTextDocumentSynchronize;
    case Incremental:
      return incrementalTextDocumentSynchronize;
    default:
      throw new RuntimeException("Unsupported synchronization kind: " + kind);
  }
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
@Inject
public LanguageServerReconcileStrategy(
    TextDocumentSynchronizeFactory synchronizeFactory,
    @Assisted ServerCapabilities serverCapabilities) {

  Either<TextDocumentSyncKind, TextDocumentSyncOptions> sync =
      serverCapabilities.getTextDocumentSync();
  TextDocumentSyncKind documentSync;
  if (sync.isLeft()) {
    documentSync = sync.getLeft();
  } else {
    documentSync = sync.getRight().getChange();
  }

  synchronize = synchronizeFactory.getSynchronize(documentSync);
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
@Override
public CompletableFuture<InitializeResult> initialize(final InitializeParams params) {
  InitializeResult result = new InitializeResult();
  ServerCapabilities cap = new ServerCapabilities();

  cap.setTextDocumentSync(TextDocumentSyncKind.Full);
  cap.setDocumentSymbolProvider(true);
  cap.setWorkspaceSymbolProvider(true);
  cap.setDefinitionProvider(true);
  cap.setCodeLensProvider(new CodeLensOptions(true));
  cap.setExecuteCommandProvider(
      new ExecuteCommandOptions(Lists.newArrayList(SomMinitest.COMMAND)));

  CompletionOptions completion = new CompletionOptions();
  List<String> autoComplTrigger = new ArrayList<>();
  autoComplTrigger.add("#"); // Smalltalk symbols
  autoComplTrigger.add(":"); // end of keywords, to complete arguments
  autoComplTrigger.add("="); // right-hand side of assignments
  completion.setTriggerCharacters(autoComplTrigger);
  completion.setResolveProvider(false); // TODO: look into that

  cap.setCompletionProvider(completion);
  result.setCapabilities(cap);

  loadWorkspace(params);

  return CompletableFuture.completedFuture(result);
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
@Test
public void testWillSaveAndWillSaveWaitUntilCapabilities() throws Exception {
	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.TRUE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);
	when(mockCapabilies.isWillSaveRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isWillSaveWaitUntilRegistered()).thenReturn(Boolean.TRUE);
	InitializeResult result = initialize(true);
	Either<TextDocumentSyncKind, TextDocumentSyncOptions> o = result.getCapabilities().getTextDocumentSync();
	assertTrue(o.isRight());
	assertTrue(o.getRight().getWillSave());
	assertTrue(o.getRight().getWillSaveWaitUntil());
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
public TextDocumentChangeRegistrationOptions(@NonNull final TextDocumentSyncKind syncKind) {
  this.syncKind = syncKind;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
/**
 * How documents are synced to the server. See TextDocumentSyncKind.Full
 * and TextDocumentSyncKind.Incremental.
 */
@Pure
@NonNull
public TextDocumentSyncKind getSyncKind() {
  return this.syncKind;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
/**
 * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
 * and TextDocumentSyncKind.Incremental.
 */
@Pure
public TextDocumentSyncKind getChange() {
  return this.change;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
/**
 * Defines how text documents are synced. Is either a detailed structure defining each notification or
 * for backwards compatibility the TextDocumentSyncKind number.
 */
@Pure
public Either<TextDocumentSyncKind, TextDocumentSyncOptions> getTextDocumentSync() {
  return this.textDocumentSync;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
public void setTextDocumentSync(final TextDocumentSyncKind textDocumentSync) {
  this.textDocumentSync = Either.forLeft(textDocumentSync);
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
public Either<TextDocumentSyncKind, TextDocumentSyncOptions> getTextDocumentSync() {
  return mergeTextDocumentSync(left.getTextDocumentSync(), right.getTextDocumentSync());
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
private Either<TextDocumentSyncKind, TextDocumentSyncOptions> mergeTextDocumentSync(
    Either<TextDocumentSyncKind, TextDocumentSyncOptions> left,
    Either<TextDocumentSyncKind, TextDocumentSyncOptions> right) {
  if (left == null) {
    return right;
  }
  if (right == null) {
    return left;
  }
  if (left.equals(right)) {
    return left;
  }

  if (left.isLeft() && left.getLeft() == TextDocumentSyncKind.Full) {
    return left;
  }

  if (left.isLeft() && left.getLeft() == TextDocumentSyncKind.Incremental) {
    if (right.isLeft() && right.getLeft() == TextDocumentSyncKind.Full) {
      return right;
    } else {
      return left;
    }
  }

  if (left.isRight() && right.isRight()) {
    TextDocumentSyncOptions leftRight = left.getRight();
    TextDocumentSyncOptions rightRight = right.getRight();
    if (leftRight.getChange() == TextDocumentSyncKind.Full) {
      return left;
    }

    if (leftRight.getChange() == TextDocumentSyncKind.Incremental) {
      if (rightRight.getChange() == TextDocumentSyncKind.Full) {
        return right;
      } else {
        return left;
      }
    }
  }

  if (left.isLeft() && right.isRight()) {
    return right;
  }

  if (left.isRight() && right.isLeft()) {
    return left;
  }
  return right;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
  ServerCapabilities capabilities = new ServerCapabilities();
  capabilities.setTextDocumentSync(TextDocumentSyncKind.Incremental);
  return CompletableFuture.completedFuture(new InitializeResult(capabilities));
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
/**
 * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
 * and TextDocumentSyncKind.Incremental.
 */
public void setChange(final TextDocumentSyncKind change) {
  this.change = change;
}
 

import org.eclipse.lsp4j.TextDocumentSyncKind; //导入依赖的package包/类
/**
 * How documents are synced to the server. See TextDocumentSyncKind.Full
 * and TextDocumentSyncKind.Incremental.
 */
public void setSyncKind(@NonNull final TextDocumentSyncKind syncKind) {
  this.syncKind = syncKind;
}