microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 11:35:42 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Clean up js decl code in checker+utilities

Browse Source
This commit is contained in:
Nathan Shively-Sanders 2018-02-14 15:48:20 -08:00
parent bad155f072
commit 0cadfcf6df
6 changed files with 200 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/compiler/checker.ts
View File

@ -4174,6 +4174,11 @@ namespace ts {
}
function getWidenedTypeFromJSSpecialPropertyDeclarations(symbol: Symbol) {
// function/class/{} assignments are fresh declarations, not property assignments:
const specialDeclaration = getAssignedJavascriptInitializer(symbol.valueDeclaration);
if (specialDeclaration) {
return getWidenedLiteralType(checkExpressionCached(specialDeclaration));
}
const types: Type[] = [];
let definedInConstructor = false;
let definedInMethod = false;
@ -4367,18 +4372,6 @@ namespace ts {
if (isInJavaScriptFile(declaration) && isJSDocPropertyLikeTag(declaration) && declaration.typeExpression) {
return links.type = getTypeFromTypeNode(declaration.typeExpression.type);
}
if (isInJavaScriptFile(declaration) && isDeclarationOfDefaultedJavascriptContainerExpression(declaration)) {
// !!! (probably out of place, probably not the right function to call)
return links.type = checkExpression(((declaration as VariableDeclaration).initializer as BinaryExpression).right);
}
if (isInJavaScriptFile(declaration) && isAssignmentOfDefaultedJavascriptContainerExpression(declaration.parent)) {
// !!! (probably out of place, probably not the right function to call)
return links.type = checkExpression(((declaration.parent as BinaryExpression).right as BinaryExpression).right);
}
// TODO: Not sure this is needed (probably, but I need to write a test case for it)
if (isInJavaScriptFile(declaration) && isAssignmentOfJavascriptContainerExpression(declaration)) {
return links.type = checkExpression((declaration.parent as BinaryExpression).right);
}
// Handle variable, parameter or property
if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
return unknownType;
@ -4399,7 +4392,6 @@ namespace ts {
|| isIdentifier(declaration)
|| (isMethodDeclaration(declaration) && !isObjectLiteralMethod(declaration))
|| isMethodSignature(declaration)) {
// TODO: Might need to add a case here?
// Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty`
if (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
return getTypeOfFuncClassEnumModule(symbol);
@ -14120,7 +14112,8 @@ namespace ts {
// expression has no contextual type, the right operand is contextually typed by the type of the left operand,
// except for the special case of Javascript declarations of the form `namespace.prop = namespace.prop || {}`
const type = getContextualType(binaryExpression);
return !type && node === right && !isDeclarationOfDefaultedJavascriptContainerExpression(binaryExpression.parent) && !isAssignmentOfDefaultedJavascriptContainerExpression(binaryExpression.parent) ? getTypeOfExpression(left, /*cache*/ true) : type;
return !type && node === right && !getDeclaredJavascriptInitializer(binaryExpression.parent) && !getAssignedJavascriptInitializer(binaryExpression) ?
getTypeOfExpression(left, /*cache*/ true) : type;
case SyntaxKind.AmpersandAmpersandToken:
case SyntaxKind.CommaToken:
return node === right ? getContextualType(binaryExpression) : undefined;
@ -18994,7 +18987,7 @@ namespace ts {
}
function checkBinaryExpression(node: BinaryExpression, checkMode?: CheckMode) {
if (node.operatorToken.kind === SyntaxKind.BarBarToken && isInJavaScriptFile(node) && isAssignmentOfDefaultedJavascriptContainerExpression(node.parent)) {
if (node.operatorToken.kind === SyntaxKind.BarBarToken && isInJavaScriptFile(node) && getAssignedJavascriptInitializer(node)) {
return checkExpression(node.right, checkMode);
}
return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, checkMode, node);
@ -19352,10 +19345,11 @@ namespace ts {
}
function checkDeclarationInitializer(declaration: HasExpressionInitializer) {
const type = getTypeOfExpression(declaration.initializer, /*cache*/ true);
const initializer = isInJavaScriptFile(declaration) && getDeclaredJavascriptInitializer(declaration) || declaration.initializer;
const type = getTypeOfExpression(initializer, /*cache*/ true);
return getCombinedNodeFlags(declaration) & NodeFlags.Const ||
(getCombinedModifierFlags(declaration) & ModifierFlags.Readonly && !isParameterPropertyDeclaration(declaration)) ||
isTypeAssertion(declaration.initializer) ? type : getWidenedLiteralType(type);
isTypeAssertion(initializer) ? type : getWidenedLiteralType(type);
}
function isLiteralOfContextualType(candidateType: Type, contextualType: Type): boolean {
@ -21872,7 +21866,7 @@ namespace ts {
// Node is the primary declaration of the symbol, just validate the initializer
// Don't validate for-in initializer as it is already an error
if (node.initializer && node.parent.parent.kind !== SyntaxKind.ForInStatement) {
const initializer = isInJavaScriptFile(node) && isDeclarationOfDefaultedJavascriptContainerExpression(node) ? (node.initializer as BinaryExpression).right : node.initializer;
const initializer = isInJavaScriptFile(node) && getDeclaredJavascriptInitializer(node) || node.initializer;
checkTypeAssignableTo(checkExpressionCached(initializer), type, node, /*headMessage*/ undefined);
checkParameterInitializer(node);
}

81
src/compiler/utilities.ts
View File

@ -1487,60 +1487,57 @@ namespace ts {
}
export function follow(symbol: Symbol) {
return symbol && isDeclarationOfJavascriptContainerExpression(symbol.valueDeclaration) ? (symbol.valueDeclaration as VariableDeclaration).initializer.symbol :
symbol && isDeclarationOfDefaultedJavascriptContainerExpression(symbol.valueDeclaration) ? ((symbol.valueDeclaration as VariableDeclaration).initializer as BinaryExpression).right.symbol :
symbol && symbol.valueDeclaration && isAssignmentOfDefaultedJavascriptContainerExpression(symbol.valueDeclaration.parent) ? (((symbol.valueDeclaration.parent as BinaryExpression).right as BinaryExpression).right as BinaryExpression).symbol :
symbol && isAssignmentOfJavascriptContainerExpression(symbol.valueDeclaration) ? ((symbol.valueDeclaration.parent as BinaryExpression).right as BinaryExpression).symbol :
symbol;
if (!symbol || !symbol.valueDeclaration) {
return symbol;
}
const declaration = symbol.valueDeclaration;
const e = getDeclaredJavascriptInitializer(declaration) || getAssignedJavascriptInitializer(declaration);
return e ? e.symbol : symbol;
}
/**
* Returns true if the node is a variable declaration whose initializer is a function or class expression, or an empty object literal.
* This function does not test if the node is in a JavaScript file or not.
*/
export function isDeclarationOfJavascriptContainerExpression(node: Node): node is VariableDeclaration {
return node &&
isVariableDeclaration(node) &&
node.initializer &&
isJavascriptContainerExpression(node.initializer);
export function getDeclaredJavascriptInitializer(node: Node) {
if (node && isVariableDeclaration(node) && node.initializer) {
return getJavascriptInitializer(node.initializer) ||
isIdentifier(node.name) && getDefaultedJavascriptInitializer(node.name, node.initializer);
}
}
function isJavascriptContainerExpression(e: Expression) {
return e.kind === SyntaxKind.FunctionExpression ||
e.kind === SyntaxKind.ClassExpression ||
isObjectLiteralExpression(e) && e.properties.length === 0;
export function getAssignedJavascriptInitializer(node: Node) {
return (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.BarBarToken || isPropertyAccessExpression(node)) &&
node.parent && isBinaryExpression(node.parent) &&
node.parent.operatorToken.kind === SyntaxKind.EqualsToken &&
(getJavascriptInitializer(node.parent.right) || getDefaultedJavascriptInitializer(node.parent.left as EntityNameExpression, node.parent.right));
}
export function isDeclarationOfDefaultedJavascriptContainerExpression(node: Node): node is VariableDeclaration {
return node &&
isVariableDeclaration(node) &&
node.initializer &&
isBinaryExpression(node.initializer) &&
isIdentifier(node.name) &&
isSameName(node.name, node.initializer.left as EntityNameExpression) &&
isJavascriptContainerExpression(node.initializer.right);
function getJavascriptInitializer(e: Expression) {
if(e.kind === SyntaxKind.FunctionExpression ||
e.kind === SyntaxKind.ClassExpression ||
isObjectLiteralExpression(e) && e.properties.length === 0) {
return e;
}
}
export function isAssignmentOfJavascriptContainerExpression(node: Node) {
return node &&
isPropertyAccessExpression(node) &&
isBinaryExpression(node.parent) &&
node.parent.right &&
isJavascriptContainerExpression(node.parent.right);
function getDefaultedJavascriptInitializer(name: EntityNameExpression, initializer: Expression) {
const e = isBinaryExpression(initializer) && getJavascriptInitializer(initializer.right)
if (e && isSameEntityName(name, (initializer as BinaryExpression).left as EntityNameExpression)) {
return e;
}
}
export function isAssignmentOfDefaultedJavascriptContainerExpression(node: Node) {
// or ... uh ... maybe not? usage is pretty inconvenient
// (changing what is the declaration might instead be the right answer)
return node &&
isBinaryExpression(node) &&
node.right &&
isBinaryExpression(node.right) &&
isSameName(node.left as EntityNameExpression, node.right.left as EntityNameExpression) &&
isJavascriptContainerExpression(node.right.right);
}
function isSameName(name: EntityNameExpression, initializer: EntityNameExpression): boolean {
/**
* Is the 'declared' name the same as the one in the initializer?
* @return true for identical entity names, as well as ones where the initializer is prefixed with
* 'window', 'self' or 'global'. For example:
*
* var my = my || {}
* var min = window.min || {}
* my.app = self.my.app || class { }
*/
function isSameEntityName(name: EntityNameExpression, initializer: EntityNameExpression): boolean {
if (isIdentifier(name) && isIdentifier(initializer)) {
return name.escapedText === initializer.escapedText;
}
@ -1550,10 +1547,10 @@ namespace ts {
(initializer.expression.escapedText === "window" as __String ||
initializer.expression.escapedText === "self" as __String ||
initializer.expression.escapedText === "global" as __String)) &&
isSameName(name, initializer.name);
isSameEntityName(name, initializer.name);
}
if (isPropertyAccessExpression(name) && isPropertyAccessExpression(initializer)) {
return name.name.escapedText === initializer.name.escapedText && isSameName(name.expression, initializer.expression);
return name.name.escapedText === initializer.name.escapedText && isSameEntityName(name.expression, initializer.expression);
}
return false;
}

28
tests/baselines/reference/typeFromPropertyAssignment10.symbols
View File

@ -13,11 +13,11 @@ Outer.app = Outer.app || {};
=== tests/cases/conformance/salsa/someview.js ===
Outer.app.SomeView = (function () {
>Outer.app.SomeView : Symbol(app.SomeView, Decl(someview.js, 0, 0))
>Outer.app.SomeView : Symbol(Outer.app.SomeView, Decl(someview.js, 0, 0))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>SomeView : Symbol(app.SomeView, Decl(someview.js, 0, 0))
>SomeView : Symbol(Outer.app.SomeView, Decl(someview.js, 0, 0))
var SomeView = function() {
>SomeView : Symbol(SomeView, Decl(someview.js, 1, 7))
@ -30,11 +30,11 @@ Outer.app.SomeView = (function () {
})();
Outer.app.Inner = class {
>Outer.app.Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Outer.app.Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
constructor() {
/** @type {number} */
@ -46,11 +46,11 @@ Outer.app.Inner = class {
}
var example = new Outer.app.Inner();
>example : Symbol(example, Decl(someview.js, 12, 3))
>Outer.app.Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Outer.app.Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
example.y;
>example.y : Symbol((Anonymous class).y, Decl(someview.js, 7, 19))
@ -59,11 +59,11 @@ example.y;
/** @param {number} k */
Outer.app.statische = function (k) {
>Outer.app.statische : Symbol(app.statische, Decl(someview.js, 13, 10))
>Outer.app.statische : Symbol(Outer.app.statische, Decl(someview.js, 13, 10))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>statische : Symbol(app.statische, Decl(someview.js, 13, 10))
>statische : Symbol(Outer.app.statische, Decl(someview.js, 13, 10))
>k : Symbol(k, Decl(someview.js, 15, 32))
return k ** k;
@ -90,11 +90,11 @@ Outer.app.Application = (function () {
me.view = new Outer.app.SomeView();
>me : Symbol(me, Decl(application.js, 7, 11))
>Outer.app.SomeView : Symbol(app.SomeView, Decl(someview.js, 0, 0))
>Outer.app.SomeView : Symbol(Outer.app.SomeView, Decl(someview.js, 0, 0))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>SomeView : Symbol(app.SomeView, Decl(someview.js, 0, 0))
>SomeView : Symbol(Outer.app.SomeView, Decl(someview.js, 0, 0))
};
return Application;
@ -112,11 +112,11 @@ var app = new Outer.app.Application();
var inner = new Outer.app.Inner();
>inner : Symbol(inner, Decl(main.js, 1, 3))
>Outer.app.Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Outer.app.Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Inner : Symbol(app.Inner, Decl(someview.js, 5, 5))
>Inner : Symbol(Outer.app.Inner, Decl(someview.js, 5, 5))
inner.y;
>inner.y : Symbol((Anonymous class).y, Decl(someview.js, 7, 19))
@ -133,9 +133,9 @@ x.y;
>y : Symbol((Anonymous class).y, Decl(someview.js, 7, 19))
Outer.app.statische(101); // Infinity, duh
>Outer.app.statische : Symbol(app.statische, Decl(someview.js, 13, 10))
>Outer.app.statische : Symbol(Outer.app.statische, Decl(someview.js, 13, 10))
>Outer.app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>Outer : Symbol(Outer, Decl(module.js, 0, 3), Decl(someview.js, 0, 0), Decl(application.js, 0, 0))
>app : Symbol(app, Decl(module.js, 0, 24), Decl(someview.js, 0, 6), Decl(application.js, 0, 6))
>statische : Symbol(app.statische, Decl(someview.js, 13, 10))
>statische : Symbol(Outer.app.statische, Decl(someview.js, 13, 10))

135
tests/baselines/reference/typeFromPropertyAssignment9.symbols
View File

@ -1,12 +1,12 @@
=== tests/cases/conformance/salsa/a.js ===
var my = my || {};
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
/** @param {number} n */
my.method = function(n) {
>my.method : Symbol(method, Decl(a.js, 0, 18))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>method : Symbol(method, Decl(a.js, 0, 18))
>n : Symbol(n, Decl(a.js, 2, 21))
@ -15,28 +15,28 @@ my.method = function(n) {
}
my.number = 1;
>my.number : Symbol(number, Decl(a.js, 4, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>number : Symbol(number, Decl(a.js, 4, 1))
my.object = {};
>my.object : Symbol(object, Decl(a.js, 5, 14))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>object : Symbol(object, Decl(a.js, 5, 14))
my.predicate = my.predicate || {};
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
my.predicate.query = function () {
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>query : Symbol(query, Decl(a.js, 7, 34))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
var me = this;
>me : Symbol(me, Decl(a.js, 9, 7))
@ -48,74 +48,85 @@ my.predicate.query = function () {
};
var q = new my.predicate.query();
>q : Symbol(q, Decl(a.js, 12, 3))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>query : Symbol(query, Decl(a.js, 7, 34))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
my.predicate.query.another = function () {
>my.predicate.query.another : Symbol((Anonymous function).another, Decl(a.js, 12, 33))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>another : Symbol((Anonymous function).another, Decl(a.js, 12, 33))
return 1;
}
my.predicate.query.result = 'none'
>my.predicate.query.result : Symbol((Anonymous function).result, Decl(a.js, 12, 33))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>query : Symbol(query, Decl(a.js, 7, 34))
>result : Symbol((Anonymous function).result, Decl(a.js, 12, 33))
>my.predicate.query.result : Symbol((Anonymous function).result, Decl(a.js, 15, 1))
>my.predicate.query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>query : Symbol(query, Decl(a.js, 7, 34), Decl(a.js, 13, 13))
>result : Symbol((Anonymous function).result, Decl(a.js, 15, 1))
/** @param {number} first
* @param {number} second
*/
my.predicate.sort = my.predicate.sort || function (first, second) {
>my.predicate.sort : Symbol(sort, Decl(a.js, 13, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>sort : Symbol(sort, Decl(a.js, 13, 34))
>my.predicate.sort : Symbol(sort, Decl(a.js, 13, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>sort : Symbol(sort, Decl(a.js, 13, 34))
>first : Symbol(first, Decl(a.js, 17, 51))
>second : Symbol(second, Decl(a.js, 17, 57))
>my.predicate.sort : Symbol(sort, Decl(a.js, 16, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>sort : Symbol(sort, Decl(a.js, 16, 34))
>my.predicate.sort : Symbol(sort, Decl(a.js, 16, 34))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>sort : Symbol(sort, Decl(a.js, 16, 34))
>first : Symbol(first, Decl(a.js, 20, 51))
>second : Symbol(second, Decl(a.js, 20, 57))
return first > second ? first : second;
>first : Symbol(first, Decl(a.js, 17, 51))
>second : Symbol(second, Decl(a.js, 17, 57))
>first : Symbol(first, Decl(a.js, 17, 51))
>second : Symbol(second, Decl(a.js, 17, 57))
>first : Symbol(first, Decl(a.js, 20, 51))
>second : Symbol(second, Decl(a.js, 20, 57))
>first : Symbol(first, Decl(a.js, 20, 51))
>second : Symbol(second, Decl(a.js, 20, 57))
}
my.predicate.type = class {
>my.predicate.type : Symbol(type, Decl(a.js, 19, 1))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 20, 3))
>type : Symbol(type, Decl(a.js, 19, 1))
>my.predicate.type : Symbol(type, Decl(a.js, 22, 1))
>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18), Decl(a.js, 5, 14), Decl(a.js, 7, 34), Decl(a.js, 12, 33) ... and 1 more)
>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 8, 3), Decl(a.js, 13, 3), Decl(a.js, 23, 3))
>type : Symbol(type, Decl(a.js, 22, 1))
m() { return 101; }
>m : Symbol((Anonymous class).m, Decl(a.js, 20, 27))
>m : Symbol((Anonymous class).m, Decl(a.js, 23, 27))
}
// global-ish prefixes
var min = window.min || {};
>min : Symbol(min, Decl(a.js, 26, 3))
>min : Symbol(min, Decl(a.js, 29, 3))
min.nest = this.min.nest || function () { };
>min.nest : Symbol(nest, Decl(a.js, 26, 27))
>min : Symbol(min, Decl(a.js, 26, 3))
>nest : Symbol(nest, Decl(a.js, 26, 27))
>min.nest : Symbol(nest, Decl(a.js, 29, 27))
>min : Symbol(min, Decl(a.js, 29, 3))
>nest : Symbol(nest, Decl(a.js, 29, 27))
min.nest.other = self.min.nest.other || class { };
>min.nest.other : Symbol((Anonymous function).other, Decl(a.js, 27, 44))
>min.nest : Symbol(nest, Decl(a.js, 26, 27))
>min : Symbol(min, Decl(a.js, 26, 3))
>nest : Symbol(nest, Decl(a.js, 26, 27))
>other : Symbol((Anonymous function).other, Decl(a.js, 27, 44))
>min.nest.other : Symbol((Anonymous function).other, Decl(a.js, 30, 44))
>min.nest : Symbol(nest, Decl(a.js, 29, 27))
>min : Symbol(min, Decl(a.js, 29, 3))
>nest : Symbol(nest, Decl(a.js, 29, 27))
>other : Symbol((Anonymous function).other, Decl(a.js, 30, 44))
min.property = global.min.property || {};
>min.property : Symbol(property, Decl(a.js, 28, 50))
>min : Symbol(min, Decl(a.js, 26, 3))
>property : Symbol(property, Decl(a.js, 28, 50))
>min.property : Symbol(property, Decl(a.js, 31, 50))
>min : Symbol(min, Decl(a.js, 29, 3))
>property : Symbol(property, Decl(a.js, 31, 50))

104
tests/baselines/reference/typeFromPropertyAssignment9.types
View File

@ -1,15 +1,15 @@
=== tests/cases/conformance/salsa/a.js ===
var my = my || {};
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my || {} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>{} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my || {} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>{} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
/** @param {number} n */
my.method = function(n) {
>my.method = function(n) { return n + 1;} : (n: number) => number
>my.method : (n: number) => number
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>method : (n: number) => number
>function(n) { return n + 1;} : (n: number) => number
>n : number
@ -22,45 +22,45 @@ my.method = function(n) {
my.number = 1;
>my.number = 1 : 1
>my.number : number
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>number : number
>1 : 1
my.object = {};
>my.object = {} : { [x: string]: any; }
>my.object : { [x: string]: any; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>object : { [x: string]: any; }
>{} : { [x: string]: any; }
my.predicate = my.predicate || {};
>my.predicate = my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>{} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate = my.predicate || {} : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate || {} : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>{} : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
my.predicate.query = function () {
>my.predicate.query = function () { var me = this; me.property = false;} : { (): void; result: string; }
>my.predicate.query : { (): void; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; result: string; }
>function () { var me = this; me.property = false;} : { (): void; result: string; }
>my.predicate.query = function () { var me = this; me.property = false;} : { (): void; another: () => number; result: string; }
>my.predicate.query : { (): void; another: () => number; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; another: () => number; result: string; }
>function () { var me = this; me.property = false;} : { (): void; another: () => number; result: string; }
var me = this;
>me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>this : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>me : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>this : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
me.property = false;
>me.property = false : false
>me.property : any
>me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>me : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>property : any
>false : false
@ -68,20 +68,34 @@ my.predicate.query = function () {
var q = new my.predicate.query();
>q : any
>new my.predicate.query() : any
>my.predicate.query : { (): void; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; result: string; }
>my.predicate.query : { (): void; another: () => number; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; another: () => number; result: string; }
my.predicate.query.another = function () {
>my.predicate.query.another = function () { return 1;} : () => number
>my.predicate.query.another : () => number
>my.predicate.query : { (): void; another: () => number; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; another: () => number; result: string; }
>another : () => number
>function () { return 1;} : () => number
return 1;
>1 : 1
}
my.predicate.query.result = 'none'
>my.predicate.query.result = 'none' : "none"
>my.predicate.query.result : string
>my.predicate.query : { (): void; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; result: string; }
>my.predicate.query : { (): void; another: () => number; result: string; }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>query : { (): void; another: () => number; result: string; }
>result : string
>'none' : "none"
@ -91,15 +105,15 @@ my.predicate.query.result = 'none'
my.predicate.sort = my.predicate.sort || function (first, second) {
>my.predicate.sort = my.predicate.sort || function (first, second) { return first > second ? first : second;} : (first: number, second: number) => number
>my.predicate.sort : (first: number, second: number) => number
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>sort : (first: number, second: number) => number
>my.predicate.sort || function (first, second) { return first > second ? first : second;} : (first: number, second: number) => number
>my.predicate.sort : (first: number, second: number) => number
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>sort : (first: number, second: number) => number
>function (first, second) { return first > second ? first : second;} : (first: number, second: number) => number
>first : number
@ -116,9 +130,9 @@ my.predicate.sort = my.predicate.sort || function (first, second) {
my.predicate.type = class {
>my.predicate.type = class { m() { return 101; }} : typeof (Anonymous class)
>my.predicate.type : typeof (Anonymous class)
>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my.predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
>predicate : { [x: string]: any; query: { (): void; another: () => number; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
>type : typeof (Anonymous class)
>class { m() { return 101; }} : typeof (Anonymous class)

3
tests/cases/conformance/salsa/typeFromPropertyAssignment9.ts
View File

@ -17,6 +17,9 @@ my.predicate.query = function () {
me.property = false;
};
var q = new my.predicate.query();
my.predicate.query.another = function () {
return 1;
}
my.predicate.query.result = 'none'
/** @param {number} first
* @param {number} second