LSP | Client implementation of the Language Server Protocol | Code Editor library

You are correct. As your code is written, creating an Employee will require that its name attribute be given a value. But as written, your code will not initialize name when creating a Developer. Just as you say, this leads to a Developer object not behaving like an Employee object, so it violates LSP.

Your solution of adding a constructor that takes a value for the name attribute does indeed solve the problem. The standard way to get this same behavior is to annotate Developer as a data class as well so that you get the proper constructor for free:

I finally had enough time to try around a bit more and found that providing your own language for the same extension is enough.

In package.json I added an element in contributes.languages with extensions containing .cpp (since I am using cpp files for testing).

I also copied over some implementation code from an example.

This suppressed the default highlighter and code completion for cpp files. Since i am only implementing a semantic token provider, I can see the default highlighting before my provider takes over. (I think this could be solved by adding a syntax highlighter, but this is already sufficient fo my preliminary testing)

I am not sure, how stable all of this would be as a plugin (I only tested in Extension Development Host mode)

Here an image of the results:

Sounds like a more configurable approach is needed, where the users can map the drives with whatever path they want (G:, S:\ or whatever). But they can still use the tools that are inside said drive.

To do this there are three things that would help:

1.) start using AutoCAD profiles. It's possible write a setup script to create the profile for the user. This profile would contain a support file path entry for the location of your LISP code. The path would vary depending on where the user has google drive mapped to.
2.) load all LISP from the profile when AutoCAD starts up, this can be done with the acaddoc.lsp file.
3.) remove all hard-coded load statements from the CUI buttons

ccls tries to find SomeClass.hpp in the root of your project. It should be fine when you change the first line of your main.cpp to this (At least for me it resolved the error):

Yes, specializing collections like this is often the example given for the usefulness of "generic" or "templated" types. Rather than extending the base class, you would specialise it with a type parameter, giving something like this:

The core idea of Liskov's Substitution Principle is that you could use instances of the subtype whenever you may use instances of the type. The subtype may be more specialized but it should comply with the same contract.

In your example, PauseButton fulfills LSP with regard to Button if all its "methods" (we say "operations" in UML) comply with the contract defined for Button. It's not just about implementing the methods but making sure that the methods are compatible:

1. PauseButton may not strengthen the preconditions of Button. I.e. if the conditions are fulfilled to perform a Button method, you should be able to perform the corresonding PauseButton method as well.
2. PauseButton may not weaken the postconditions of Button. I.e. if Button makes some promises about a method, PauseButton must fulfill at least the same promises.
3. Invariants of Button (logical conditions that should be always true) should also be invariants of PauseButton. PauseButton may have additional invariants.
4. History constraint: roughly speaking, it means that whereas PauseButton is a Button, PauseButton methods should not modify directly its Button state, without using methods of the Button. No shortcut.

In the case of abstract subclasses, it's more delicate to verify LSP since we cannot look at direct instances. Nevertheless, the subclasses could be indirectly instantiated by concrete subclasses that provide the missing methods:

• If at least one of the three PauseButton methods that you implement infringes LSP (i.e. are incompatible with the same method from Button), then PauseButton violates LSP.
• But if all the three methods are compliant, and if PauseButton does not redefine the contract of the other methods, you can assume that PauseButton is LSP-Compliant : you could create a concrete subclass of PauseButton that would be compliant, even if at the present stage such sublass doesn't exist. This fulfills the requirements for interchangeability.

Step 1: Ensure R is setup right:

In your JSON settings, change r.rpath.windows and --r-binary from

"C:\\Users\\XXXXX\\Documents\\R\\R-4.0.3\\bin\\x64\\R.exe"

to

"C:\\Users\\XXXXX\\Documents\\R\\R-4.0.3\\bin\\R.exe"

(That is, drop the \\x64--and don't worry, VSCode should still open 64-bit R even with these changes).

Step 2: Fix the issue of running an R Script from the Editor:

In your JSON settings, add the following line:

The default config from nvim-cmp was also calling setup{} which effectively cleared the on_attach callback required to enable the lsp keybindings.

You are going to run into issues with this setup. See these related GitHub issues 1, 2.

Instead, use Deno's LSP in one workspace (your backend) and the vanilla TS LSP in the other workspace (your frontend), using exclusive VS Code settings files in each. (If you do repo top-level scripting with Deno, then it's fine to duplicate that VS Code config for the top-level, too.)

Then, open a separate VS Code window for each workspace in your monorepo so that they can use their own LSPs without conflict.