1111

pending completion

Build # 1111

Build Type

Pull #268

travis-ci-com

Committed by

web-flow

Commit Message

Merge 6b14ece0a into 299daca68

Pull Request Pull Request #268: Migrate lib/compiler to TypeScript

Run Details

4343 of 5883 branches covered (73.82%)

Branch coverage included in aggregate %.

748 of 830 new or added lines in 15 files covered. (90.12%)

138 existing lines in 4 files now uncovered.

9161 of 10972 relevant lines covered (83.49%)

1618.09 hits per line

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

80.56

/lib/compiler/scope.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2019 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: Giovanni Campagna <gcampagn@cs.stanford.edu>

import type * as Ast from '../ast';

import { Register } from './jsir';
import Type from '../type';
import type { CompiledStatement } from './index';

export interface RegisterScopeEntry {
    type : 'scalar';
    register : Register;
    tt_type : Type|null;
    direction : 'input'|'output'|'special';
    isInVarScopeNames : boolean;
}
export interface DeclarationScopeEntry {
    type : 'declaration';
    register : Register|null;
    schema : Ast.ExpressionSignature;
    args : string[];
    code : string|CompiledStatement|null;
}
export interface ProcedureScopeEntry {
    type : 'procedure';
    register : Register|null;
    schema : Ast.ExpressionSignature;
    args : string[];
    code : string|CompiledStatement|null;
}
export interface AssignmentScopeEntry {
    type : 'assignment';
    register : Register;
    schema : Ast.ExpressionSignature;
    isPersistent : boolean;
}

export type ScopeEntry =
    RegisterScopeEntry |
    DeclarationScopeEntry |
    ProcedureScopeEntry |
    AssignmentScopeEntry;

export default class Scope {
    private _parent : Scope|null;
    private _names : { [key : string] : ScopeEntry };

    constructor(parent : Scope|null = null) {
        this._parent = parent;
        if (parent !== null && !(parent instanceof Scope))
            throw new TypeError(`wrong parent scope`);
        this._names = Object.create(null);
    }

    // catch refactoring bugs...
    get $outputType() : never {
        throw new TypeError('use get($outputType)');
    }
    get $output() : never {
        throw new TypeError('use get($output)');
    }

    get parent() : Scope|null {
        return this._parent;
    }

    get isTopLevel() : boolean {
        return this._parent === null;
    }

    hasOwnKey(name : string) : boolean {
        return name in this._names;
    }

    get(name : string) : ScopeEntry {
        // we don't need to check if the name is visible in some scope,
        // we know it is because the program typechecked
        if (name in this._names)
            return this._names[name];
        else
            return this._parent!.get(name);
    }

    set(name : string, value : ScopeEntry) : void {
        this._names[name] = value;
    }

    private*_doIterate(seen : Set<string>) : Generator<[string, ScopeEntry], void> {
        for (const name in this._names) {
            if (seen.has(name))
                continue;
            seen.add(name);
            yield [name, this._names[name]];
        }
        if (this._parent)
            yield* this._parent._doIterate(seen);
    }

    *[Symbol.iterator]() : Generator<[string, ScopeEntry], void> {
        const seen = new Set<string>();
        yield* this._doIterate(seen);
    }

    *ownKeys() : Generator<string, void> {
        for (const name in this._names)
            yield name;
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2019 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: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	import type * as Ast from '../ast';
22
23	import { Register } from './jsir';
24	import Type from '../type';
25	import type { CompiledStatement } from './index';
26
27	export interface RegisterScopeEntry {
28	type : 'scalar';
29	register : Register;
30	tt_type : Type\|null;
31	direction : 'input'\|'output'\|'special';
32	isInVarScopeNames : boolean;
33	}
34	export interface DeclarationScopeEntry {
35	type : 'declaration';
36	register : Register\|null;
37	schema : Ast.ExpressionSignature;
38	args : string[];
39	code : string\|CompiledStatement\|null;
40	}
41	export interface ProcedureScopeEntry {
42	type : 'procedure';
43	register : Register\|null;
44	schema : Ast.ExpressionSignature;
45	args : string[];
46	code : string\|CompiledStatement\|null;
47	}
48	export interface AssignmentScopeEntry {
49	type : 'assignment';
50	register : Register;
51	schema : Ast.ExpressionSignature;
52	isPersistent : boolean;
53	}
54
55	export type ScopeEntry =
56	RegisterScopeEntry \|
57	DeclarationScopeEntry \|
58	ProcedureScopeEntry \|
59	AssignmentScopeEntry;
60
61	export default class Scope {	2✔
62	private _parent : Scope\|null;
63	private _names : { [key : string] : ScopeEntry };
64
65	constructor(parent : Scope\|null = null) {	680✔
66	this._parent = parent;	1,866✔
67	if (parent !== null && !(parent instanceof Scope))	1,866!
NEW 68	throw new TypeError(`wrong parent scope`);	×
69	this._names = Object.create(null);	1,866✔
70	}
71
72	// catch refactoring bugs...
73	get $outputType() : never {
NEW 74	throw new TypeError('use get($outputType)');	×
75	}
76	get $output() : never {
NEW 77	throw new TypeError('use get($output)');	×
78	}
79
80	get parent() : Scope\|null {
81	return this._parent;	100✔
82	}
83
84	get isTopLevel() : boolean {
NEW 85	return this._parent === null;	×
86	}
87
88	hasOwnKey(name : string) : boolean {
89	return name in this._names;	318✔
90	}
91
92	get(name : string) : ScopeEntry {
93	// we don't need to check if the name is visible in some scope,
94	// we know it is because the program typechecked
95	if (name in this._names)	3,660✔
96	return this._names[name];	3,442✔
97	else
98	return this._parent!.get(name);	218✔
99	}
100
101	set(name : string, value : ScopeEntry) : void {
102	this._names[name] = value;	6,010✔
103	}
104
105	private*_doIterate(seen : Set<string>) : Generator<[string, ScopeEntry], void> {
106	for (const name in this._names) {	40✔
107	if (seen.has(name))	284!
NEW 108	continue;	×
109	seen.add(name);	284✔
110	yield [name, this._names[name]];	284✔
111	}
112	if (this._parent)	40✔
113	yield* this._parent._doIterate(seen);	20✔
114	}
115
116	*[Symbol.iterator]() : Generator<[string, ScopeEntry], void> {
117	const seen = new Set<string>();	20✔
118	yield* this._doIterate(seen);	20✔
119	}
120
121	*ownKeys() : Generator<string, void> {
122	for (const name in this._names)	288✔
123	yield name;	2,276✔
124	}
125	}

stanford-oval / thingtalk / 1111

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