1794136993

Build Type

github

Committed by GitHub

Commit Message

Merge 0d65b81ba into 2179a562e

Pull Request Pull Request #7: Adds value expressions

Run Details

119 of 149 branches covered (79.87%)

Branch coverage included in aggregate %.

188 of 191 new or added lines in 7 files covered. (98.43%)

1 existing line in 1 file now uncovered.

413 of 443 relevant lines covered (93.23%)

91.37 hits per line

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

90.2

/src/core/literal/index.ts

import type { IType } from '../../typings/type';
import type { ILiteral } from '../../typings/literal';

import { capitalizeBoolean, LineInfo, parenthesis, quote } from '../../misc/utils';
import { TOption, TUnknown, TRecord, TMap, TBig_map } from '../type';
import { IExpression, IExpressionKind } from '../../typings/expression';
import { Layout } from '../enums/layout';
import LiteralAtom from '../enums/literal';
import TypeAtom from '../enums/type';

class LiteralExpression<T extends TypeAtom> implements ILiteral<T> {
    _isExpression = true as const;
    // Used for type checking
    _type = null as unknown as T;
    type = {} as unknown as IType;

    constructor(
        private name: LiteralAtom,
        private values: (number | string | boolean | IExpression)[],
        private line: LineInfo,
    ) {}

    toString() {
        switch (this.name) {
            case LiteralAtom.unit:
                return parenthesis(this.name);
            case LiteralAtom.nat:
            case LiteralAtom.int:
            case LiteralAtom.mutez:
            case LiteralAtom.bytes:
            case LiteralAtom.bool:
            case LiteralAtom.string:
            case LiteralAtom.chain_id_cst:
            case LiteralAtom.timestamp:
            case LiteralAtom.bls12_381_fr:
            case LiteralAtom.bls12_381_g1:
            case LiteralAtom.bls12_381_g2:
            case LiteralAtom.key:
            case LiteralAtom.key_hash:
            case LiteralAtom.signature:
            case LiteralAtom.address:
                return `(literal (${this.name} ${this.values.join(' ')}) ${this.line})`;
            case LiteralAtom.list:
            case LiteralAtom.set:
                return `(${this.name} ${this.line} ${this.values.join(' ')})`;
            default:
                return `(${this.name} ${this.values.join(' ')} ${this.line})`;
        }
    }
}

class OptionLiteral implements ILiteral<TypeAtom.option> {
    _isExpression = true as const;
    _type = TypeAtom.option as const;

    type: IType;

    constructor(
        private prim: LiteralAtom.Some | LiteralAtom.None,
        private value: IExpressionKind | undefined,
        private innerType: IType = TUnknown,
        private line: LineInfo,
    ) {
        this.type = TOption(innerType);
    }

    toString(): string {
        return `(${LiteralAtom.variant} "${this.prim}" ${this.value?.toString() || `(${LiteralAtom.unit})`} ${
            this.line
        })`;
    }

    toType() {
        return this.type.toString();
    }
}

class RecordLiteral implements ILiteral<TypeAtom.record> {
    _isExpression = true as const;
    _type = TypeAtom.record as const;

    type: IType;

    constructor(private fields: Record<string, ILiteral<unknown>>, private line: LineInfo) {
        // Compute the record type (use rightcombs by default)
        this.type = TRecord(
            Object.entries(fields).reduce(
                (pv, [field, expr]) => ({
                    ...pv,
                    [field]: expr.type.toString(),
                }),
                {},
            ),
            Layout.right_comb,
        );
    }

    private buildFields = (fields: Record<string, IExpressionKind>) => {
        return Object.entries(fields).map(([field, expr]) => `(${field} ${expr.toString()})`);
    };

    toString(): string {
        return `(${TypeAtom.record} ${this.line} ${this.buildFields(this.fields).join(' ')})`;
    }

    toType() {
        return this.type.toString();
    }
}

class MapLiteral<T extends TypeAtom.map | TypeAtom.big_map> implements ILiteral<T> {
    _isExpression = true as const;
    _type: T;

    type: IType;

    constructor(
        private prim: LiteralAtom.map | LiteralAtom.big_map,
        private rows: IExpression[][],
        keyType: IType,
        valueType: IType,
        private line: LineInfo,
    ) {
        if (prim === LiteralAtom.map) {
            this.type = TMap(keyType, valueType);
        } else {
            this.type = TBig_map(keyType, valueType);
        }
        // Just for typing purposes
        this._type = null as unknown as T;
    }

    private buildEntry = ([key, value]: IExpression[]) => {
        return `(${key.toString()} ${value.toString()})`;
    };

    toString() {
        return `(${this.prim} ${this.line} ${this.rows.map(this.buildEntry).join(' ')})`;
    }

    toType() {
        return this.type.toString();
    }
}

// Singletons
export const Unit = (line = new LineInfo()) => new LiteralExpression<TypeAtom.unit>(LiteralAtom.unit, [], line);
export const Nat = (value: number, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.nat>(LiteralAtom.nat, [value], line);
export const Int = (value: number, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.int>(LiteralAtom.int, [value], line);
export const Mutez = (value: number, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.mutez>(LiteralAtom.mutez, [value], line);
export const String = (value: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.string>(LiteralAtom.string, [quote(value)], line);
export const Bool = (value: boolean, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.bool>(LiteralAtom.bool, [capitalizeBoolean(value)], line);
export const Address = (address: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.address>(LiteralAtom.address, [address], line);
export const Timestamp = (timestamp: number, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.timestamp>(LiteralAtom.timestamp, [timestamp], line);
export const Chain_id = (chainID: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.chain_id>(LiteralAtom.chain_id_cst, [chainID], line);
export const Bytes = (bytes: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.bytes>(LiteralAtom.bytes, [bytes], line);
export const Bls12_381_fr = (fr: string | number, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.bls12_381_fr>(LiteralAtom.bls12_381_fr, [fr], line);
export const Bls12_381_g1 = (bytes: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.bls12_381_g1>(LiteralAtom.bls12_381_g1, [bytes], line);
export const Bls12_381_g2 = (bytes: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.bls12_381_g2>(LiteralAtom.bls12_381_g2, [bytes], line);
export const Key = (key: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.key>(LiteralAtom.key, [key], line);
export const Key_hash = (key_hash: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.key_hash>(LiteralAtom.key_hash, [key_hash], line);
export const Signature = (signature: string, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.signature>(LiteralAtom.signature, [signature], line);
// Containers
export const List = (items: IExpression[], line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.list>(LiteralAtom.list, items, line);
export const Set = (items: IExpression[], line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.set>(LiteralAtom.set, items, line);
export const Some = (value: IExpressionKind, innerType?: IType, line = new LineInfo()) =>
    new OptionLiteral(LiteralAtom.Some, value, innerType, line);
export const None = (innerType?: IType, line = new LineInfo()) =>
    new OptionLiteral(LiteralAtom.None, undefined, innerType, line);
export const Map = (
    rows: IExpression[][] = [],
    keyType: IType = TUnknown,
    valueType: IType = TUnknown,
    line = new LineInfo(),
) => new MapLiteral<TypeAtom.map>(LiteralAtom.map, rows, keyType, valueType, line);
export const Big_map = (
    rows: IExpression[][] = [],
    keyType: IType = TUnknown,
    valueType: IType = TUnknown,
    line = new LineInfo(),
) => new MapLiteral<TypeAtom.big_map>(LiteralAtom.big_map, rows, keyType, valueType, line);
export const Pair = (left: IExpression, right: IExpression, line = new LineInfo()) =>
    new LiteralExpression<TypeAtom.tuple>(LiteralAtom.tuple, [left, right], line);

export const Record = (fields: Record<string, ILiteral<unknown>>, line = new LineInfo()) =>
    new RecordLiteral(fields, line);

const Literals = {
    // Singletons
    Unit,
    Nat,
    Int,
    Mutez,
    String,
    Bool,
    Bytes,
    Address,
    Timestamp,
    Chain_id,
    Bls12_381_fr,
    Bls12_381_g1,
    Bls12_381_g2,
    Key,
    Key_hash,
    Signature,
    // Container types
    List,
    Set,
    Some,
    None,
    Pair,
    Map,
    Big_map,
    // Lambda,
    // Ticket,
    // Contract,
    // Sapling_state,
    // Sapling_transaction,
    // Artificial Types
    Record,
    // Variant,
};

export default Literals;

1	import type { IType } from '../../typings/type';
2	import type { ILiteral } from '../../typings/literal';
3
4	import { capitalizeBoolean, LineInfo, parenthesis, quote } from '../../misc/utils';	21✔
5	import { TOption, TUnknown, TRecord, TMap, TBig_map } from '../type';	21✔
6	import { IExpression, IExpressionKind } from '../../typings/expression';
7	import { Layout } from '../enums/layout';	21✔
8	import LiteralAtom from '../enums/literal';	21✔
9	import TypeAtom from '../enums/type';	21✔
10
11	class LiteralExpression<T extends TypeAtom> implements ILiteral<T> {
12	_isExpression = true as const;	714✔
13	// Used for type checking
14	_type = null as unknown as T;	714✔
15	type = {} as unknown as IType;	714✔
16
17	constructor(
18	private name: LiteralAtom,	714✔
19	private values: (number \| string \| boolean \| IExpression)[],	714✔
20	private line: LineInfo,	714✔
21	) {}
22
23	toString() {
24	switch (this.name) {	486!
25	case LiteralAtom.unit:
26	return parenthesis(this.name);	102✔
27	case LiteralAtom.nat:
28	case LiteralAtom.int:
29	case LiteralAtom.mutez:
30	case LiteralAtom.bytes:
31	case LiteralAtom.bool:
32	case LiteralAtom.string:
33	case LiteralAtom.chain_id_cst:
34	case LiteralAtom.timestamp:
35	case LiteralAtom.bls12_381_fr:
36	case LiteralAtom.bls12_381_g1:
37	case LiteralAtom.bls12_381_g2:
38	case LiteralAtom.key:
39	case LiteralAtom.key_hash:
40	case LiteralAtom.signature:
41	case LiteralAtom.address:
42	return `(literal (${this.name} ${this.values.join(' ')}) ${this.line})`;	369✔
43	case LiteralAtom.list:
44	case LiteralAtom.set:
45	return `(${this.name} ${this.line} ${this.values.join(' ')})`;	15✔
46	default:
NEW 47	return `(${this.name} ${this.values.join(' ')} ${this.line})`;	×
48	}
49	}
50	}
51
52	class OptionLiteral implements ILiteral<TypeAtom.option> {
53	_isExpression = true as const;	72✔
54	_type = TypeAtom.option as const;	72✔
55
56	type: IType;
57
58	constructor(
59	private prim: LiteralAtom.Some \| LiteralAtom.None,	72✔
60	private value: IExpressionKind \| undefined,	72✔
61	private innerType: IType = TUnknown,	72✔
62	private line: LineInfo,	72✔
63	) {
64	this.type = TOption(innerType);	72✔
65	}
66
67	toString(): string {
68	return `(${LiteralAtom.variant} "${this.prim}" ${this.value?.toString() \|\| `(${LiteralAtom.unit})`} ${	72✔
69	this.line
70	})`;
71	}
72
73	toType() {
74	return this.type.toString();	×
75	}
76	}
77
78	class RecordLiteral implements ILiteral<TypeAtom.record> {
79	_isExpression = true as const;	12✔
80	_type = TypeAtom.record as const;	12✔
81
82	type: IType;
83
84	constructor(private fields: Record<string, ILiteral<unknown>>, private line: LineInfo) {	12✔
85	// Compute the record type (use rightcombs by default)
86	this.type = TRecord(	12✔
87	Object.entries(fields).reduce(
88	(pv, [field, expr]) => ({	33✔
89	...pv,
90	[field]: expr.type.toString(),
91	}),
92	{},
93	),
94	Layout.right_comb,
95	);
96	}
97
98	private buildFields = (fields: Record<string, IExpressionKind>) => {	12✔
99	return Object.entries(fields).map(([field, expr]) => `(${field} ${expr.toString()})`);	33✔
100	};
101
102	toString(): string {
103	return `(${TypeAtom.record} ${this.line} ${this.buildFields(this.fields).join(' ')})`;	12✔
104	}
105
106	toType() {
107	return this.type.toString();	×
108	}
109	}
110
111	class MapLiteral<T extends TypeAtom.map \| TypeAtom.big_map> implements ILiteral<T> {
112	_isExpression = true as const;	15✔
113	_type: T;
114
115	type: IType;
116
117	constructor(
118	private prim: LiteralAtom.map \| LiteralAtom.big_map,	15✔
119	private rows: IExpression[][],	15✔
120	keyType: IType,
121	valueType: IType,
122	private line: LineInfo,	15✔
123	) {
124	if (prim === LiteralAtom.map) {	15!
UNCOV 125	this.type = TMap(keyType, valueType);	×
126	} else {
127	this.type = TBig_map(keyType, valueType);	15✔
128	}
129	// Just for typing purposes
130	this._type = null as unknown as T;	15✔
131	}
132
133	private buildEntry = ([key, value]: IExpression[]) => {	15✔
134	return `(${key.toString()} ${value.toString()})`;	×
135	};
136
137	toString() {
138	return `(${this.prim} ${this.line} ${this.rows.map(this.buildEntry).join(' ')})`;	15✔
139	}
140
141	toType() {
142	return this.type.toString();	×
143	}
144	}
145
146	// Singletons
147	export const Unit = (line = new LineInfo()) => new LiteralExpression<TypeAtom.unit>(LiteralAtom.unit, [], line);	327✔
148	export const Nat = (value: number, line = new LineInfo()) =>	21✔
149	new LiteralExpression<TypeAtom.nat>(LiteralAtom.nat, [value], line);	51✔
150	export const Int = (value: number, line = new LineInfo()) =>	21✔
151	new LiteralExpression<TypeAtom.int>(LiteralAtom.int, [value], line);	3✔
152	export const Mutez = (value: number, line = new LineInfo()) =>	21✔
153	new LiteralExpression<TypeAtom.mutez>(LiteralAtom.mutez, [value], line);	231✔
154	export const String = (value: string, line = new LineInfo()) =>	21✔
155	new LiteralExpression<TypeAtom.string>(LiteralAtom.string, [quote(value)], line);	36✔
156	export const Bool = (value: boolean, line = new LineInfo()) =>	21✔
157	new LiteralExpression<TypeAtom.bool>(LiteralAtom.bool, [capitalizeBoolean(value)], line);	9✔
158	export const Address = (address: string, line = new LineInfo()) =>	21✔
159	new LiteralExpression<TypeAtom.address>(LiteralAtom.address, [address], line);	9✔
160	export const Timestamp = (timestamp: number, line = new LineInfo()) =>	21✔
161	new LiteralExpression<TypeAtom.timestamp>(LiteralAtom.timestamp, [timestamp], line);	3✔
162	export const Chain_id = (chainID: string, line = new LineInfo()) =>	21✔
163	new LiteralExpression<TypeAtom.chain_id>(LiteralAtom.chain_id_cst, [chainID], line);	3✔
164	export const Bytes = (bytes: string, line = new LineInfo()) =>	21✔
165	new LiteralExpression<TypeAtom.bytes>(LiteralAtom.bytes, [bytes], line);	3✔
166	export const Bls12_381_fr = (fr: string \| number, line = new LineInfo()) =>	21✔
167	new LiteralExpression<TypeAtom.bls12_381_fr>(LiteralAtom.bls12_381_fr, [fr], line);	6✔
168	export const Bls12_381_g1 = (bytes: string, line = new LineInfo()) =>	21✔
169	new LiteralExpression<TypeAtom.bls12_381_g1>(LiteralAtom.bls12_381_g1, [bytes], line);	3✔
170	export const Bls12_381_g2 = (bytes: string, line = new LineInfo()) =>	21✔
171	new LiteralExpression<TypeAtom.bls12_381_g2>(LiteralAtom.bls12_381_g2, [bytes], line);	3✔
172	export const Key = (key: string, line = new LineInfo()) =>	21✔
173	new LiteralExpression<TypeAtom.key>(LiteralAtom.key, [key], line);	3✔
174	export const Key_hash = (key_hash: string, line = new LineInfo()) =>	21✔
175	new LiteralExpression<TypeAtom.key_hash>(LiteralAtom.key_hash, [key_hash], line);	6✔
176	export const Signature = (signature: string, line = new LineInfo()) =>	21✔
177	new LiteralExpression<TypeAtom.signature>(LiteralAtom.signature, [signature], line);	3✔
178	// Containers
179	export const List = (items: IExpression[], line = new LineInfo()) =>	21✔
180	new LiteralExpression<TypeAtom.list>(LiteralAtom.list, items, line);	12✔
181	export const Set = (items: IExpression[], line = new LineInfo()) =>	21✔
182	new LiteralExpression<TypeAtom.set>(LiteralAtom.set, items, line);	3✔
183	export const Some = (value: IExpressionKind, innerType?: IType, line = new LineInfo()) =>	21✔
184	new OptionLiteral(LiteralAtom.Some, value, innerType, line);	36✔
185	export const None = (innerType?: IType, line = new LineInfo()) =>	21✔
186	new OptionLiteral(LiteralAtom.None, undefined, innerType, line);	36✔
187	export const Map = (	21✔
188	rows: IExpression[][] = [],	×
189	keyType: IType = TUnknown,	×
190	valueType: IType = TUnknown,	×
191	line = new LineInfo(),	×
NEW 192	) => new MapLiteral<TypeAtom.map>(LiteralAtom.map, rows, keyType, valueType, line);	×
193	export const Big_map = (	21✔
194	rows: IExpression[][] = [],	3✔
195	keyType: IType = TUnknown,	3✔
196	valueType: IType = TUnknown,	3✔
197	line = new LineInfo(),	15✔
198	) => new MapLiteral<TypeAtom.big_map>(LiteralAtom.big_map, rows, keyType, valueType, line);	15✔
199	export const Pair = (left: IExpression, right: IExpression, line = new LineInfo()) =>	21!
NEW 200	new LiteralExpression<TypeAtom.tuple>(LiteralAtom.tuple, [left, right], line);	×
201
202	export const Record = (fields: Record<string, ILiteral<unknown>>, line = new LineInfo()) =>	21✔
203	new RecordLiteral(fields, line);	12✔
204
205	const Literals = {	21✔
206	// Singletons
207	Unit,
208	Nat,
209	Int,
210	Mutez,
211	String,
212	Bool,
213	Bytes,
214	Address,
215	Timestamp,
216	Chain_id,
217	Bls12_381_fr,
218	Bls12_381_g1,
219	Bls12_381_g2,
220	Key,
221	Key_hash,
222	Signature,
223	// Container types
224	List,
225	Set,
226	Some,
227	None,
228	Pair,
229	Map,
230	Big_map,
231	// Lambda,
232	// Ticket,
233	// Contract,
234	// Sapling_state,
235	// Sapling_transaction,
236	// Artificial Types
237	Record,
238	// Variant,
239	};
240
241	export default Literals;	21✔

RomarQ / smartts-sdk / 1794136993

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