bug: Go to definition doesn't work on the second component in a single file about angular HOT 5 CLOSED

OK, I'll take a look.

from angular.

This appears to have been broken by angular/vscode-ng-language-service@bd6282e. @ivanwonder If you have and time, would you be able to take a look at this? I clearly don't understand the tokenizer and can't look into it more anytime soon.

from angular.

@ivanwonder Thank you! We don't necessarily need the whole implementation that TypeScript has for this because we don't care about tokenizing all the parts correctly. All we really need to know is where the start and end is of the string. But maybe the easiest way to do that is just tokenizing the whole thing correctly by copying the TS code.

from angular.

Yes, the tokenizer is complex, and I also can't fully understand it, and make sure this will work for us.

1. const a =`abc`

The token is ts.SyntaxKind.NoSubstitutionTemplateLiteral which includes the CloseBraceToken. We don't need to call the reScanTemplateToken.

2. const a = `ab${1}c`

We need to call the reScanTemplateToken when encountering a CloseBraceToken.

3. const a = `ab${b({})}c`

This includes an object {}, we need to record the OpenBraceToken, close them all, then call the reScanTemplateToken.

But maybe the easiest way to do that is just tokenizing the whole thing correctly by copying the TS code.

I think this is what the ts.createSourceFile does. Scan the code and create the AST tree.
https://github.com/microsoft/TypeScript/blob/806d7340472082e5ff6d844ecdb70a4b5165e8c5/src/compiler/parser.ts#L1592

I have an idea about the original problem, I guess which is the diagnostics can be quite expensive. In the typescript the type checker can be interrupted.

    // Cancellation that controls whether or not we can cancel in the middle of type checking.
    // In general cancelling is *not* safe for the type checker.  We might be in the middle of
    // computing something, and we will leave our internals in an inconsistent state.  Callers
    // who set the cancellation token should catch if a cancellation exception occurs, and
    // should throw away and create a new TypeChecker.
    //
    // Currently we only support setting the cancellation token when getting diagnostics.  This
    // is because diagnostics can be quite expensive, and we want to allow hosts to bail out if
    // they no longer need the information (for example, if the user started editing again).
    var cancellationToken: CancellationToken | undefined;

function runWithCancellationToken<T>(func: () => T): T {
        try {
            return func();
        }
        catch (e) {
            if (e instanceof OperationCanceledException) {
                // We were canceled while performing the operation.  Because our type checker
                // might be a bad state, we need to throw it away.
                typeChecker = undefined!;
            }

            throw e;
        }
    }

This copy is from here. https://github.com/microsoft/TypeScript/blob/806d7340472082e5ff6d844ecdb70a4b5165e8c5/src/compiler/checker.ts#L1435
https://github.com/microsoft/TypeScript/blob/806d7340472082e5ff6d844ecdb70a4b5165e8c5/src/compiler/program.ts#L2853

Maybe we can evaluate this option, and try to throw an error in the template type checker and catch the error in the NgCompiler when the request is canceled.

from angular.

I think this is what the ts.createSourceFile does. Scan the code and create the AST tree.

Yea, this is probably the direction we should go at this point (creating a temporary source file). We can copy the same code used on the server side here:

from angular.