Build has been canceled!

1250

pending completion

Build # 1250

Build Type

Pull #310

travis-ci-com

Committed by

web-flow

Commit Message

Merge 4e1103d90 into 3a985e9bd

Pull Request Pull Request #310: Add support for existential subquery

Run Details

4309 of 6076 branches covered (70.92%)

Branch coverage included in aggregate %.

68 of 92 new or added lines in 10 files covered. (73.91%)

142 existing lines in 10 files now uncovered.

10004 of 12439 relevant lines covered (80.42%)

48009.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.0

/lib/ast/base.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2019-2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Silei Xu <silei@cs.stanford.edu>

import assert from 'assert';
import NodeVisitor from './visitor';

import type {
    Invocation,
    ExternalBooleanExpression
} from './expression';
import type { Value } from './values';
import type {
    InvocationAction,
    VarRefAction,
    InvocationTable,
    VarRefTable,
    VarRefStream
} from './primitive';
import type {
    InvocationExpression,
    FunctionCallExpression
} from './expression2';
import {
    SourceRange,
    SourceLocation
} from '../utils/source_locations';

import { TokenStream, ConstantToken } from '../new-syntax/tokenstream';
import {
    SyntaxType,
    serialize,
} from '../syntax_api';
import List from '../utils/list';

// reexport those types for the benefit of ThingTalk API consumers
export {
    SourceRange,
    SourceLocation
};

export type NLAnnotationMap = { [key : string] : any };
export type AnnotationMap = { [key : string] : Value };

export interface AnnotationSpec {
    nl ?: NLAnnotationMap;
    impl ?: AnnotationMap;
}

export type Primitive = Invocation |
    VarRefTable |
    VarRefAction |
    VarRefStream |
    FunctionCallExpression |
    ExternalBooleanExpression;

export function implAnnotationsToSource(map : AnnotationMap, prefix = '\n') : TokenStream {
    let syntax : TokenStream = List.Nil;
    for (const key in map) {
        syntax = List.concat(syntax,
            prefix, '#[', key, '=', map[key].toSource(), ']');
    }
    return syntax;
}

export function toJSON(value : unknown) : TokenStream {
    if (Array.isArray(value)) {
        return List.concat('[', List.join(value.map(toJSON), ','), ']');
    } else if (typeof value === 'object' && value !== null) {
        let list : TokenStream = List.singleton('{');
        let first = true;
        const object = value as { [key : string] : unknown };
        for (const key in object) {
            const inner = object[key];
            if (first) {
                list = List.concat(list, '\n', '\t+');
                first = false;
            } else {
                list = List.concat(list, ',', '\n');
            }
            list = List.concat(list, key, '=', toJSON(inner));
        }
        if (first)
            list = List.concat(list, '}');
        else
            list = List.concat(list, '\n', '\t-', '}');
        return list;
    } else if (typeof value === 'string') {
        return List.singleton(new ConstantToken('QUOTED_STRING', value));
    } else {
        return List.singleton(String(value));
    }
}

export function nlAnnotationsToSource(map : NLAnnotationMap, prefix = '\n') : TokenStream {
    let syntax : TokenStream = List.Nil;
    for (const key of Object.keys(map)) {
        syntax = List.concat(syntax,
            prefix, '#_[', key, '=', toJSON(map[key]), ']');
    }
    return syntax;
}

/**
 * Base class of AST nodes.
 *
 * @class
 * @alias Ast~Node
 * @abstract
 */
export default abstract class Node {
    location : SourceRange|null;

    /**
     * Construct a new AST node.
     *
     * @param location - the position of this node in the source code
     */
    constructor(location : SourceRange|null = null) {
        assert(location === null ||
            (typeof location.start === 'object' && typeof location.end === 'object'));

        /**
         * The location of this node in the source code, or `null` if the
         * node is not associated with any source.
         *
         * @type {Ast~SourceRange|null}
         * @readonly
         */
        this.location = location;
    }

    /**
     * Traverse the current subtree using the visitor pattern.
     * See {@link Ast.NodeVisitor} for details and example usage.
     *
     * @param {Ast.NodeVisitor} visitor - the visitor to use.
     */
    abstract visit(visitor : NodeVisitor) : void;

    abstract clone() : Node;

    /**
     * Optimize this AST node.
     *
     * Optimization removes redundant operations and converts ThingTalk to canonical form.
     *
     * @returns {Ast~Node} the optimized node
     */
    optimize() : Node {
        return this;
    }

    /* istanbul ignore next */
    /**
     * Convert this AST node to a sequence of tokens.
     */
    abstract toSource() : TokenStream;

    /**
     * Convert this AST node to a normalized surface form in ThingTalk.
     */
    prettyprint() : string {
        return serialize(this, SyntaxType.Normal);
    }

    /**
     * Iterate all primitives (Thingpedia function invocations) in the subtree of this
     * AST node (including the node itself).
     *
     * This method is implemented using {@link Ast.NodeVisitor}. It is recommended to use
     * {@link Ast.NodeVisitor} directly to traverse ASTs instead of this or similar methods.
     *
     * @param {boolean} includeVarRef - whether to include local function calls (VarRef nodes)
     *                                  in the iteration
     * @deprecated Use {@link Ast.NodeVisitor}.
     */
    iteratePrimitives(includeVarRef : false) : Array<[('action'|'query'|'stream'|'filter'|'expression'), Invocation|ExternalBooleanExpression]>;
    iteratePrimitives(includeVarRef : boolean) : Array<[('action'|'query'|'stream'|'filter'|'expression'), Primitive]>;
    iteratePrimitives(includeVarRef : boolean) : Array<[('action'|'query'|'stream'|'filter'|'expression'), Primitive]> {
        // we cannot yield from inside the visitor, so we buffer everything
        const buffer : Array<[('action'|'query'|'stream'|'filter'|'expression'), Primitive]> = [];
        const visitor = new class extends NodeVisitor {
            visitVarRefAction(node : VarRefAction) {
                if (includeVarRef)
                    buffer.push(['action', node]);
                return true;
            }
            visitInvocationAction(node : InvocationAction) {
                buffer.push(['action', node.invocation]);
                return true;
            }
            visitVarRefTable(node : VarRefTable) {
                if (includeVarRef)
                    buffer.push(['query', node]);
                return true;
            }
            visitInvocationTable(node : InvocationTable) {
                buffer.push(['query', node.invocation]);
                return true;
            }
            visitVarRefStream(node : VarRefStream) {
                if (includeVarRef)
                    buffer.push(['stream', node]);
                return true;
            }
            visitFunctionCallExpression(node : FunctionCallExpression) {
                if (!includeVarRef)
                    return true;
                if (node.schema)
                    buffer.push([node.schema.functionType, node]);
                else
                    buffer.push(['expression', node]);
                return true;
            }
            visitInvocationExpression(node : InvocationExpression) {
                if (node.schema)
                    buffer.push([node.schema.functionType, node.invocation]);
                else
                    buffer.push(['expression', node.invocation]);
                return true;
            }
            visitExternalBooleanExpression(node : ExternalBooleanExpression) {
                buffer.push(['filter', node]);
                return true;
            }
        };

        this.visit(visitor);
        return buffer;
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2019-2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Silei Xu <silei@cs.stanford.edu>
20
21	import assert from 'assert';	2✔
22	import NodeVisitor from './visitor';	2✔
23
24	import type {
25	Invocation,
26	ExternalBooleanExpression
27	} from './expression';
28	import type { Value } from './values';
29	import type {
30	InvocationAction,
31	VarRefAction,
32	InvocationTable,
33	VarRefTable,
34	VarRefStream
35	} from './primitive';
36	import type {
37	InvocationExpression,
38	FunctionCallExpression
39	} from './expression2';
40	import {
41	SourceRange,
42	SourceLocation
43	} from '../utils/source_locations';
44
45	import { TokenStream, ConstantToken } from '../new-syntax/tokenstream';	2✔
46	import {	2✔
47	SyntaxType,
48	serialize,
49	} from '../syntax_api';
50	import List from '../utils/list';	2✔
51
52	// reexport those types for the benefit of ThingTalk API consumers
53	export {
54	SourceRange,
55	SourceLocation
56	};
57
58	export type NLAnnotationMap = { [key : string] : any };
59	export type AnnotationMap = { [key : string] : Value };
60
61	export interface AnnotationSpec {
62	nl ?: NLAnnotationMap;
63	impl ?: AnnotationMap;
64	}
65
66	export type Primitive = Invocation \|
67	VarRefTable \|
68	VarRefAction \|
69	VarRefStream \|
70	FunctionCallExpression \|
71	ExternalBooleanExpression;
72
73	export function implAnnotationsToSource(map : AnnotationMap, prefix = '\n') : TokenStream {	2✔
74	let syntax : TokenStream = List.Nil;	7,162✔
75	for (const key in map) {	7,162✔
76	syntax = List.concat(syntax,	1,894✔
77	prefix, '#[', key, '=', map[key].toSource(), ']');
78	}
79	return syntax;	7,162✔
80	}
81
82	export function toJSON(value : unknown) : TokenStream {	2✔
83	if (Array.isArray(value)) {	1,848✔
84	return List.concat('[', List.join(value.map(toJSON), ','), ']');	482✔
85	} else if (typeof value === 'object' && value !== null) {	1,366✔
86	let list : TokenStream = List.singleton('{');	96✔
87	let first = true;	96✔
88	const object = value as { [key : string] : unknown };	96✔
89	for (const key in object) {	96✔
90	const inner = object[key];	278✔
91	if (first) {	278✔
92	list = List.concat(list, '\n', '\t+');	96✔
93	first = false;	96✔
94	} else {
95	list = List.concat(list, ',', '\n');	182✔
96	}
97	list = List.concat(list, key, '=', toJSON(inner));	278✔
98	}
99	if (first)	96!
100	list = List.concat(list, '}');	×
101	else
102	list = List.concat(list, '\n', '\t-', '}');	96✔
103	return list;	96✔
104	} else if (typeof value === 'string') {	1,270✔
105	return List.singleton(new ConstantToken('QUOTED_STRING', value));	1,238✔
106	} else {
107	return List.singleton(String(value));	32✔
108	}
109	}
110
111	export function nlAnnotationsToSource(map : NLAnnotationMap, prefix = '\n') : TokenStream {	2✔
112	let syntax : TokenStream = List.Nil;	7,162✔
113	for (const key of Object.keys(map)) {	7,162✔
114	syntax = List.concat(syntax,	970✔
115	prefix, '#_[', key, '=', toJSON(map[key]), ']');
116	}
117	return syntax;	7,162✔
118	}
119
120	/**
121	* Base class of AST nodes.
122	*
123	* @class
124	* @alias Ast~Node
125	* @abstract
126	*/
127	export default abstract class Node {	2✔
128	location : SourceRange\|null;
129
130	/**
131	* Construct a new AST node.
132	*
133	* @param location - the position of this node in the source code
134	*/
135	constructor(location : SourceRange\|null = null) {	×
136	assert(location === null \|\|	704,968✔
137	(typeof location.start === 'object' && typeof location.end === 'object'));
138
139	/**
140	* The location of this node in the source code, or `null` if the
141	* node is not associated with any source.
142	*
143	* @type {Ast~SourceRange\|null}
144	* @readonly
145	*/
146	this.location = location;	704,968✔
147	}
148
149	/**
150	* Traverse the current subtree using the visitor pattern.
151	* See {@link Ast.NodeVisitor} for details and example usage.
152	*
153	* @param {Ast.NodeVisitor} visitor - the visitor to use.
154	*/
155	abstract visit(visitor : NodeVisitor) : void;
156
157	abstract clone() : Node;
158
159	/**
160	* Optimize this AST node.
161	*
162	* Optimization removes redundant operations and converts ThingTalk to canonical form.
163	*
164	* @returns {Ast~Node} the optimized node
165	*/
166	optimize() : Node {
167	return this;	70✔
168	}
169
170	/* istanbul ignore next */
171	/**
172	* Convert this AST node to a sequence of tokens.
173	*/
174	abstract toSource() : TokenStream;
175
176	/**
177	* Convert this AST node to a normalized surface form in ThingTalk.
178	*/
179	prettyprint() : string {
180	return serialize(this, SyntaxType.Normal);	3,272✔
181	}
182
183	/**
184	* Iterate all primitives (Thingpedia function invocations) in the subtree of this
185	* AST node (including the node itself).
186	*
187	* This method is implemented using {@link Ast.NodeVisitor}. It is recommended to use
188	* {@link Ast.NodeVisitor} directly to traverse ASTs instead of this or similar methods.
189	*
190	* @param {boolean} includeVarRef - whether to include local function calls (VarRef nodes)
191	* in the iteration
192	* @deprecated Use {@link Ast.NodeVisitor}.
193	*/
194	iteratePrimitives(includeVarRef : false) : Array<[('action'\|'query'\|'stream'\|'filter'\|'expression'), Invocation\|ExternalBooleanExpression]>;
195	iteratePrimitives(includeVarRef : boolean) : Array<[('action'\|'query'\|'stream'\|'filter'\|'expression'), Primitive]>;
196	iteratePrimitives(includeVarRef : boolean) : Array<[('action'\|'query'\|'stream'\|'filter'\|'expression'), Primitive]> {
197	// we cannot yield from inside the visitor, so we buffer everything
198	const buffer : Array<[('action'\|'query'\|'stream'\|'filter'\|'expression'), Primitive]> = [];	2,702✔
199	const visitor = new class extends NodeVisitor {	2,702✔
200	visitVarRefAction(node : VarRefAction) {
201	if (includeVarRef)	×
202	buffer.push(['action', node]);	×
203	return true;	×
204	}
205	visitInvocationAction(node : InvocationAction) {
206	buffer.push(['action', node.invocation]);	20✔
207	return true;	20✔
208	}
209	visitVarRefTable(node : VarRefTable) {
210	if (includeVarRef)	×
211	buffer.push(['query', node]);	×
212	return true;	×
213	}
214	visitInvocationTable(node : InvocationTable) {
215	buffer.push(['query', node.invocation]);	16✔
216	return true;	16✔
217	}
218	visitVarRefStream(node : VarRefStream) {
219	if (includeVarRef)	×
220	buffer.push(['stream', node]);	×
221	return true;	×
222	}
223	visitFunctionCallExpression(node : FunctionCallExpression) {
224	if (!includeVarRef)	640✔
225	return true;	632✔
226	if (node.schema)	8!
227	buffer.push([node.schema.functionType, node]);	8✔
228	else
229	buffer.push(['expression', node]);	×
230	return true;	8✔
231	}
232	visitInvocationExpression(node : InvocationExpression) {
233	if (node.schema)	3,408✔
234	buffer.push([node.schema.functionType, node.invocation]);	152✔
235	else
236	buffer.push(['expression', node.invocation]);	3,256✔
237	return true;	3,408✔
238	}
239	visitExternalBooleanExpression(node : ExternalBooleanExpression) {
UNCOV 240	buffer.push(['filter', node]);	×
UNCOV 241	return true;	×
242	}
243	};
244
245	this.visit(visitor);	2,702✔
246	return buffer;	2,702✔
247	}
248	}

stanford-oval / thingtalk / 1250

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous