avoid adding declaration for invalid js

Author: a-tarasyuk

src/compiler/binder.ts

@@ -3430,6 +3430,10 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
     }
 
     function bindPropertyOrMethodOrAccessor(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags) {
+        if (isInJSFile(node) && (node.flags & NodeFlags.Ambient)) {
+            return;
+        }
+
         if (!file.isDeclarationFile && !(node.flags & NodeFlags.Ambient) && isAsyncFunction(node)) {
             emitFlags |= NodeFlags.HasAsyncFunctions;
         }

src/compiler/checker.ts

@@ -9567,13 +9567,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         if (!type) {
             let types: Type[] | undefined;
-            let declarations: Declaration[] | undefined;
             if (symbol.declarations) {
                 let jsdocType: Type | undefined;
                 for (const declaration of symbol.declarations) {
-                    if (isInJSFile(declaration) && hasSyntacticModifier(declaration, ModifierFlags.Ambient)) {
-                        continue;
-                    }
                     const expression = (isBinaryExpression(declaration) || isCallExpression(declaration)) ? declaration :
                         isAccessExpression(declaration) ? isBinaryExpression(declaration.parent) ? declaration.parent : declaration :
                             undefined;
@@ -9597,15 +9593,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (!jsdocType) {
                         (types ??= []).push((isBinaryExpression(expression) || isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
                     }
-                    (declarations ??= []).push(declaration);
                 }
                 type = jsdocType;
             }
             if (!type) {
                 if (!length(types)) {
                     return errorType; // No types from any declarations :(
                 }
-                let constructorTypes = definedInConstructor && declarations ? getConstructorDefinedThisAssignmentTypes(types!, declarations) : undefined;
+                let constructorTypes = definedInConstructor && symbol.declarations ? getConstructorDefinedThisAssignmentTypes(types!, symbol.declarations) : undefined;
                 // use only the constructor types unless they were only assigned null | undefined (including widening variants)
                 if (definedInMethod) {
                     const propType = getTypeOfPropertyInBaseClass(symbol);