docs: function checkCallExpression(node) {
              // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
              checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
              var signature = getResolvedSignature(node);
              if (node.expression.kind === 95 /* SuperKeyword */) {
                  return voidType;
              }
              if (node.kind === 175 /* NewExpression */) {
                  var declaration = signature.declaration;
                  if (declaration &&
                      declaration.kind !== 148 /* Constructor */ &&
                      declaration.kind !== 152 /* ConstructSignature */ &&
                      declaration.kind !== 157 /* ConstructorType */ &&
                      !ts.isJSDocConstructSignature(declaration)) {
                      // When resolved signature is a call signature (and not a construct signature) the result type is any, unless
                      // the declaring function had members created through 'x.prototype.y = expr' or 'this.y = expr' psuedodeclarations
                      // in a JS file
                      // Note:JS inferred classes might come from a variable declaration instead of a function declaration.
                      // In this case, using getResolvedSymbol directly is required to avoid losing the members from the declaration.
                      var funcSymbol = node.expression.kind === 69 /* Identifier */ ?
                          getResolvedSymbol(node.expression) :
                          checkExpression(node.expression).symbol;
                      if (funcSymbol && funcSymbol.members && (funcSymbol.flags & 16 /* Function */ || ts.isDeclarationOfFunctionExpression(funcSymbol))) {
                          return getInferredClassType(funcSymbol);
                      }
                      else if (compilerOptions.noImplicitAny) {
                          error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
                      }
                      return anyType;
                  }
              }
              // In JavaScript files, calls to any identifier 'require' are treated as external module imports
              if (ts.isInJavaScriptFile(node) && ts.isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
                  return resolveExternalModuleTypeByLiteral(node.arguments[0]);
              }
              return getReturnTypeOfSignature(signature);
          }