mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-05-11 19:11:10 -05:00
Code Issues Packages Projects Releases 164 Wiki Activity

Merge pull request #595 from arv/rename-type-ref-js

Browse Source 
JS: Rename TypeRef to Type
This commit is contained in:
Erik Arvidsson
2015-11-10 16:44:04 -05:00
parent f52e41323f ceb2481efb
commit 5d239d4735
13 changed files with 236 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files
js2/src/decode.js
+35 -35
View File
@@ -7,7 +7,7 @@ import Ref from './ref.js';
import Struct from './struct.js';
import type {ChunkStore} from './chunk_store.js';
import type {NomsKind} from './noms_kind.js';
import {Field, makeCompoundTypeRef, makePrimitiveTypeRef, makeStructTypeRef, makeTypeRef, makeUnresolvedTypeRef, StructDesc, TypeRef} from './type_ref.js';
import {Field, makeCompoundType, makePrimitiveType, makeStructType, makeType, makeUnresolvedType, StructDesc, Type} from './type.js';
import {invariant, notNull} from './assert.js';
import {isPrimitiveKind, Kind} from './noms_kind.js';
import {lookupPackage, Package, readPackage} from './package.js';
@@ -70,37 +70,37 @@ class JsonArrayReader {
return Ref.parse(next);
}
readTypeRefAsTag(): TypeRef {
readTypeAsTag(): Type {
let kind = this.readKind();
switch (kind) {
case Kind.List:
case Kind.Set:
case Kind.Ref: {
let elemType = this.readTypeRefAsTag();
return makeCompoundTypeRef(kind, elemType);
let elemType = this.readTypeAsTag();
return makeCompoundType(kind, elemType);
}
case Kind.Map: {
let keyType = this.readTypeRefAsTag();
let valueType = this.readTypeRefAsTag();
return makeCompoundTypeRef(kind, keyType, valueType);
let keyType = this.readTypeAsTag();
let valueType = this.readTypeAsTag();
return makeCompoundType(kind, keyType, valueType);
}
case Kind.TypeRef:
return makePrimitiveTypeRef(Kind.TypeRef);
case Kind.Type:
return makePrimitiveType(Kind.Type);
case Kind.Unresolved: {
let pkgRef = this.readRef();
let ordinal = this.readOrdinal();
return makeTypeRef(pkgRef, ordinal);
return makeType(pkgRef, ordinal);
}
}
if (isPrimitiveKind(kind)) {
return makePrimitiveTypeRef(kind);
return makePrimitiveType(kind);
}
throw new Error('Unreachable');
}
async readList(t: TypeRef, pkg: ?Package): Promise<Array<any>> {
async readList(t: Type, pkg: ?Package): Promise<Array<any>> {
let elemType = t.elemTypes[0];
let list = [];
while (!this.atEnd()) {
@@ -111,12 +111,12 @@ class JsonArrayReader {
return list;
}
async readSet(t: TypeRef, pkg: ?Package): Promise<Set> {
async readSet(t: Type, pkg: ?Package): Promise<Set> {
let seq = await this.readList(t, pkg);
return new Set(seq);
}
async readMap(t: TypeRef, pkg: ?Package): Promise<Map> {
async readMap(t: Type, pkg: ?Package): Promise<Map> {
let keyType = t.elemTypes[0];
let valueType = t.elemTypes[1];
let m = new Map();
@@ -129,11 +129,11 @@ class JsonArrayReader {
return m;
}
readPackage(t: TypeRef, pkg: ?Package): Package {
readPackage(t: Type, pkg: ?Package): Package {
let r2 = new JsonArrayReader(this.readArray(), this._cs);
let types = [];
while (!r2.atEnd()) {
types.push(r2.readTypeRefAsValue(pkg));
types.push(r2.readTypeAsValue(pkg));
}
let r3 = new JsonArrayReader(this.readArray(), this._cs);
@@ -146,11 +146,11 @@ class JsonArrayReader {
}
readTopLevelValue(): Promise<any> {
let t = this.readTypeRefAsTag();
let t = this.readTypeAsTag();
return this.readValueWithoutTag(t);
}
readValueWithoutTag(t: TypeRef, pkg: ?Package = null): Promise<any> {
readValueWithoutTag(t: Type, pkg: ?Package = null): Promise<any> {
// TODO: Verify read values match tagged kinds.
switch (t.kind) {
case Kind.Blob:
@@ -171,7 +171,7 @@ class JsonArrayReader {
case Kind.String:
return Promise.resolve(this.readString());
case Kind.Value: {
let t2 = this.readTypeRefAsTag();
let t2 = this.readTypeAsTag();
return this.readValueWithoutTag(t2, pkg);
}
case Kind.List: {
@@ -193,8 +193,8 @@ class JsonArrayReader {
case Kind.Enum:
case Kind.Struct:
throw new Error('Not allowed');
case Kind.TypeRef:
return Promise.resolve(this.readTypeRefAsValue(pkg));
case Kind.Type:
return Promise.resolve(this.readTypeAsValue(pkg));
case Kind.Unresolved:
return this.readUnresolvedKindToValue(t, pkg);
}
@@ -202,7 +202,7 @@ class JsonArrayReader {
throw new Error('Unreached');
}
async readUnresolvedKindToValue(t: TypeRef, pkg: ?Package = null): Promise<any> {
async readUnresolvedKindToValue(t: Type, pkg: ?Package = null): Promise<any> {
let pkgRef = t.packageRef;
let ordinal = t.ordinal;
if (!pkgRef.isEmpty()) {
@@ -224,7 +224,7 @@ class JsonArrayReader {
return this.readStruct(typeDef, t, pkg);
}
readTypeRefAsValue(pkg: ?Package): TypeRef {
readTypeAsValue(pkg: ?Package): Type {
let k = this.readKind();
switch (k) {
@@ -235,12 +235,12 @@ class JsonArrayReader {
case Kind.Ref:
case Kind.Set: {
let r2 = new JsonArrayReader(this.readArray(), this._cs);
let elemTypes: Array<TypeRef> = [];
let elemTypes: Array<Type> = [];
while (!r2.atEnd()) {
elemTypes.push(r2.readTypeRefAsValue());
elemTypes.push(r2.readTypeAsValue());
}
return makeCompoundTypeRef(k, ...elemTypes);
return makeCompoundType(k, ...elemTypes);
}
case Kind.Struct: {
let name = this.readString();
@@ -249,7 +249,7 @@ class JsonArrayReader {
let fieldReader = new JsonArrayReader(this.readArray(), this._cs);
while (!fieldReader.atEnd()) {
let fieldName = fieldReader.readString();
let fieldType = fieldReader.readTypeRefAsValue(pkg);
let fieldType = fieldReader.readTypeAsValue(pkg);
let optional = fieldReader.readBool();
fields.push(new Field(fieldName, fieldType, optional));
}
@@ -258,7 +258,7 @@ class JsonArrayReader {
let fields = readFields();
let choices = readFields();
return makeStructTypeRef(name, fields, choices);
return makeStructType(name, fields, choices);
}
case Kind.Unresolved: {
let pkgRef = this.readRef();
@@ -266,22 +266,22 @@ class JsonArrayReader {
if (ordinal === -1) {
let namespace = this.readString();
let name = this.readString();
invariant(pkgRef.isEmpty(), 'Unresolved TypeRefs may not have a package ref');
invariant(pkgRef.isEmpty(), 'Unresolved Types may not have a package ref');
return makeUnresolvedTypeRef(namespace, name);
return makeUnresolvedType(namespace, name);
}
return makeTypeRef(pkgRef, ordinal);
return makeType(pkgRef, ordinal);
}
}
invariant(isPrimitiveKind(k));
return makePrimitiveTypeRef(k);
return makePrimitiveType(k);
}
async readStruct(typeDef: TypeRef, typeRef: TypeRef, pkg: Package): Promise<Struct> {
// TODO FixupTypeRef?
async readStruct(typeDef: Type, type: Type, pkg: Package): Promise<Struct> {
// TODO FixupType?
let desc = typeDef.desc;
invariant(desc instanceof StructDesc);
@@ -308,7 +308,7 @@ class JsonArrayReader {
s[unionField.name] = v;
}
return new Struct(typeRef, typeDef, s);
return new Struct(type, typeDef, s);
}
}
js2/src/decode_test.js
+17 -17
View File
@@ -7,10 +7,10 @@ import MemoryStore from './memory_store.js';
import Ref from './ref.js';
import Struct from './struct.js';
import test from './async_test.js';
import type {TypeDesc} from './type_ref.js';
import type {TypeDesc} from './type.js';
import {assert} from 'chai';
import {decodeNomsValue, JsonArrayReader, readValue} from './decode.js';
import {Field, makeCompoundTypeRef, makePrimitiveTypeRef, makeStructTypeRef, makeTypeRef, TypeRef} from './type_ref.js';
import {Field, makeCompoundType, makePrimitiveType, makeStructType, makeType, Type} from './type.js';
import {invariant} from './assert.js';
import {Kind} from './noms_kind.js';
import {registerPackage, Package} from './package.js';
@@ -32,23 +32,23 @@ suite('Decode', () => {
assert.isTrue(r.atEnd());
});
test('read type ref as tag', async () => {
test('read type as tag', async () => {
let ms = new MemoryStore();
function doTest(expected: TypeRef, a: Array<any>) {
function doTest(expected: Type, a: Array<any>) {
let r = new JsonArrayReader(a, ms);
let tr = r.readTypeRefAsTag();
let tr = r.readTypeAsTag();
assert.isTrue(expected.equals(tr));
}
doTest(makePrimitiveTypeRef(Kind.Bool), [Kind.Bool, true]);
doTest(makePrimitiveTypeRef(Kind.TypeRef), [Kind.TypeRef, Kind.Bool]);
doTest(makeCompoundTypeRef(Kind.List, makePrimitiveTypeRef(Kind.Bool)), [Kind.List, Kind.Bool, true, false]);
doTest(makePrimitiveType(Kind.Bool), [Kind.Bool, true]);
doTest(makePrimitiveType(Kind.Type), [Kind.Type, Kind.Bool]);
doTest(makeCompoundType(Kind.List, makePrimitiveType(Kind.Bool)), [Kind.List, Kind.Bool, true, false]);
let pkgRef = Ref.parse('sha1-a9993e364706816aba3e25717850c26c9cd0d89d');
doTest(makeTypeRef(pkgRef, 42), [Kind.Unresolved, pkgRef.toString(), 42]);
doTest(makeType(pkgRef, 42), [Kind.Unresolved, pkgRef.toString(), 42]);
doTest(makePrimitiveTypeRef(Kind.TypeRef), [Kind.TypeRef, Kind.TypeRef, pkgRef.toString()]);
doTest(makePrimitiveType(Kind.Type), [Kind.Type, Kind.Type, pkgRef.toString()]);
});
test('read primitives', async () => {
@@ -179,10 +179,10 @@ suite('Decode', () => {
test('test read struct', async () => {
let ms = new MemoryStore();
let tr = makeStructTypeRef('A1', [
new Field('x', makePrimitiveTypeRef(Kind.Int16), false),
new Field('s', makePrimitiveTypeRef(Kind.String), false),
new Field('b', makePrimitiveTypeRef(Kind.Bool), false)
let tr = makeStructType('A1', [
new Field('x', makePrimitiveType(Kind.Int16), false),
new Field('s', makePrimitiveType(Kind.String), false),
new Field('b', makePrimitiveType(Kind.Bool), false)
], []);
let pkg = new Package([tr], []);
@@ -201,9 +201,9 @@ suite('Decode', () => {
test('test read map of string to struct', async () => {
let ms = new MemoryStore();
let tr = makeStructTypeRef('s', [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('i', makePrimitiveTypeRef(Kind.Int32), false)
let tr = makeStructType('s', [
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('i', makePrimitiveType(Kind.Int32), false)
], []);
let pkg = new Package([tr], []);
js2/src/encode.js
+21 -21
View File
@@ -10,7 +10,7 @@ import type {NomsKind} from './noms_kind.js';
import {invariant, notNull} from './assert.js';
import {isPrimitiveKind, Kind} from './noms_kind.js';
import {lookupPackage, Package} from './package.js';
import {makePrimitiveTypeRef, StructDesc, TypeRef} from './type_ref.js';
import {makePrimitiveType, StructDesc, Type} from './type.js';
const typedTag = 't ';
@@ -43,7 +43,7 @@ class JsonArrayWriter {
this.write(r.toString());
}
writeTypeRefAsTag(t: TypeRef) {
writeTypeAsTag(t: Type) {
let k = t.kind;
this.writeKind(k);
switch (k) {
@@ -54,7 +54,7 @@ class JsonArrayWriter {
case Kind.Map:
case Kind.Ref:
case Kind.Set: {
t.elemTypes.forEach(elemType => this.writeTypeRefAsTag(elemType));
t.elemTypes.forEach(elemType => this.writeTypeAsTag(elemType));
break;
}
case Kind.Unresolved: {
@@ -65,18 +65,18 @@ class JsonArrayWriter {
let pkg = lookupPackage(pkgRef);
if (pkg && this._cs) {
writeValue(pkg, pkg.typeRef, this._cs);
writeValue(pkg, pkg.type, this._cs);
}
}
}
}
writeTopLevel(t: TypeRef, v: any) {
this.writeTypeRefAsTag(t);
writeTopLevel(t: Type, v: any) {
this.writeTypeAsTag(t);
this.writeValue(v, t);
}
writeValue(v: any, t: TypeRef, pkg: ?Package) {
writeValue(v: any, t: Type, pkg: ?Package) {
switch (t.kind) {
case Kind.Blob:
throw new Error('Not implemented');
@@ -121,7 +121,7 @@ class JsonArrayWriter {
}
case Kind.Package: {
invariant(v instanceof Package);
let ptr = makePrimitiveTypeRef(Kind.TypeRef);
let ptr = makePrimitiveType(Kind.Type);
let w2 = new JsonArrayWriter(this._cs);
v.types.forEach(type => w2.writeValue(type, ptr));
this.write(w2.array);
@@ -143,9 +143,9 @@ class JsonArrayWriter {
this.write(w2.array);
break;
}
case Kind.TypeRef: {
invariant(v instanceof TypeRef);
this.writeTypeRefAsValue(v);
case Kind.Type: {
invariant(v instanceof Type);
this.writeTypeAsValue(v);
break;
}
case Kind.Unresolved: {
@@ -161,7 +161,7 @@ class JsonArrayWriter {
}
}
writeTypeRefAsValue(t: TypeRef) {
writeTypeAsValue(t: Type) {
let k = t.kind;
this.writeKind(k);
switch (k) {
@@ -172,7 +172,7 @@ class JsonArrayWriter {
case Kind.Ref:
case Kind.Set: {
let w2 = new JsonArrayWriter(this._cs);
t.elemTypes.forEach(elem => w2.writeTypeRefAsValue(elem));
t.elemTypes.forEach(elem => w2.writeTypeAsValue(elem));
this.write(w2.array);
break;
}
@@ -183,14 +183,14 @@ class JsonArrayWriter {
let fieldWriter = new JsonArrayWriter(this._cs);
desc.fields.forEach(field => {
fieldWriter.write(field.name);
fieldWriter.writeTypeRefAsValue(field.t);
fieldWriter.writeTypeAsValue(field.t);
fieldWriter.write(field.optional);
});
this.write(fieldWriter.array);
let choiceWriter = new JsonArrayWriter(this._cs);
desc.union.forEach(choice => {
choiceWriter.write(choice.name);
choiceWriter.writeTypeRefAsValue(choice.t);
choiceWriter.writeTypeAsValue(choice.t);
choiceWriter.write(choice.optional);
});
this.write(choiceWriter.array);
@@ -208,7 +208,7 @@ class JsonArrayWriter {
let pkg = lookupPackage(pkgRef);
if (pkg && this._cs) {
writeValue(pkg, pkg.typeRef, this._cs);
writeValue(pkg, pkg.type, this._cs);
}
break;
@@ -220,7 +220,7 @@ class JsonArrayWriter {
}
}
writeUnresolvedKindValue(v: any, t: TypeRef, pkg: Package) {
writeUnresolvedKindValue(v: any, t: Type, pkg: Package) {
let typeDef = pkg.types[t.ordinal];
switch (typeDef.kind) {
case Kind.Enum:
@@ -235,7 +235,7 @@ class JsonArrayWriter {
}
}
writeStruct(s: Struct, typeRef: TypeRef, typeDef: TypeRef, pkg: Package) {
writeStruct(s: Struct, type: Type, typeDef: Type, pkg: Package) {
let desc = typeDef.desc;
invariant(desc instanceof StructDesc);
for (let field of desc.fields) {
@@ -261,7 +261,7 @@ class JsonArrayWriter {
}
}
function orderValuesByRef(t: TypeRef, a: Array<any>): Array<any> {
function orderValuesByRef(t: Type, a: Array<any>): Array<any> {
return a.map(v => {
return {
v: v,
@@ -274,7 +274,7 @@ function orderValuesByRef(t: TypeRef, a: Array<any>): Array<any> {
});
}
function encodeNomsValue(v: any, t: TypeRef, cs: ?ChunkStore): Chunk {
function encodeNomsValue(v: any, t: Type, cs: ?ChunkStore): Chunk {
if (v instanceof Package) {
// if (v.dependencies.length > 0) {
// throw new Error('Not implemented');
@@ -286,7 +286,7 @@ function encodeNomsValue(v: any, t: TypeRef, cs: ?ChunkStore): Chunk {
return Chunk.fromString(typedTag + JSON.stringify(w.array));
}
function writeValue(v: any, t: TypeRef, cs: ChunkStore): Ref {
function writeValue(v: any, t: Type, cs: ChunkStore): Ref {
let chunk = encodeNomsValue(v, t, cs);
invariant(!chunk.isEmpty());
cs.put(chunk);
js2/src/encode_test.js
+53 -53
View File
@@ -9,7 +9,7 @@ import MemoryStore from './memory_store.js';
import Ref from './ref.js';
import Struct from './struct.js';
import test from './async_test.js';
import {Field, makeCompoundTypeRef, makePrimitiveTypeRef, makeStructTypeRef, makeTypeRef} from './type_ref.js';
import {Field, makeCompoundType, makePrimitiveType, makeStructType, makeType} from './type.js';
import {JsonArrayWriter} from './encode.js';
import {Kind} from './noms_kind.js';
import {Package, registerPackage} from './package.js';
@@ -19,7 +19,7 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let tr = makeCompoundTypeRef(Kind.List, makePrimitiveTypeRef(Kind.Int32));
let tr = makeCompoundType(Kind.List, makePrimitiveType(Kind.Int32));
w.writeTopLevel(tr, [0, 1, 2, 3]);
assert.deepEqual([Kind.List, Kind.Int32, [0, 1, 2, 3]], w.array);
});
@@ -28,8 +28,8 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let it = makeCompoundTypeRef(Kind.List, makePrimitiveTypeRef(Kind.Int16));
let tr = makeCompoundTypeRef(Kind.List, it);
let it = makeCompoundType(Kind.List, makePrimitiveType(Kind.Int16));
let tr = makeCompoundType(Kind.List, it);
let v = [[0], [1, 2, 3]];
w.writeTopLevel(tr, v);
assert.deepEqual([Kind.List, Kind.List, Kind.Int16, [[0], [1, 2, 3]]], w.array);
@@ -39,7 +39,7 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let tr = makeCompoundTypeRef(Kind.Set, makePrimitiveTypeRef(Kind.UInt32));
let tr = makeCompoundType(Kind.Set, makePrimitiveType(Kind.UInt32));
let v = new Set([0, 1, 2, 3]);
w.writeTopLevel(tr, v);
assert.deepEqual([Kind.Set, Kind.UInt32, [1, 3, 0, 2]], w.array);
@@ -49,8 +49,8 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let st = makeCompoundTypeRef(Kind.Set, makePrimitiveTypeRef(Kind.Int32));
let tr = makeCompoundTypeRef(Kind.Set, st);
let st = makeCompoundType(Kind.Set, makePrimitiveType(Kind.Int32));
let tr = makeCompoundType(Kind.Set, st);
let v = new Set([new Set([0]), new Set([1, 2, 3])]);
w.writeTopLevel(tr, v);
assert.deepEqual([Kind.Set, Kind.Set, Kind.Int32, [[1, 3, 2], [0]]], w.array);
@@ -60,7 +60,7 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let tr = makeCompoundTypeRef(Kind.Map, makePrimitiveTypeRef(Kind.String), makePrimitiveTypeRef(Kind.Bool));
let tr = makeCompoundType(Kind.Map, makePrimitiveType(Kind.String), makePrimitiveType(Kind.Bool));
let v = new Map();
v.set('a', false);
v.set('b', true);
@@ -72,9 +72,9 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let kt = makeCompoundTypeRef(Kind.Map, makePrimitiveTypeRef(Kind.String), makePrimitiveTypeRef(Kind.Int64));
let vt = makeCompoundTypeRef(Kind.Set, makePrimitiveTypeRef(Kind.Bool));
let tr = makeCompoundTypeRef(Kind.Map, kt, vt);
let kt = makeCompoundType(Kind.Map, makePrimitiveType(Kind.String), makePrimitiveType(Kind.Int64));
let vt = makeCompoundType(Kind.Set, makePrimitiveType(Kind.Bool));
let tr = makeCompoundType(Kind.Map, kt, vt);
let v = new Map();
let m1 = new Map();
@@ -89,15 +89,15 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let typeDef = makeStructTypeRef('S', [], []);
let typeDef = makeStructType('S', [], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let v = new Struct(typeRef, typeDef, {});
let v = new Struct(type, typeDef, {});
w.writeTopLevel(typeRef, v);
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0], w.array);
});
@@ -105,18 +105,18 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let typeDef = makeStructTypeRef('S', [
new Field('x', makePrimitiveTypeRef(Kind.Int8), false),
new Field('b', makePrimitiveTypeRef(Kind.Bool), false)
let typeDef = makeStructType('S', [
new Field('x', makePrimitiveType(Kind.Int8), false),
new Field('b', makePrimitiveType(Kind.Bool), false)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let v = new Struct(typeRef, typeDef, {x: 42, b: true});
let v = new Struct(type, typeDef, {x: 42, b: true});
w.writeTopLevel(typeRef, v);
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, 42, true], w.array);
});
@@ -124,22 +124,22 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let typeDef = makeStructTypeRef('S', [
new Field('x', makePrimitiveTypeRef(Kind.Int8), true),
new Field('b', makePrimitiveTypeRef(Kind.Bool), false)
let typeDef = makeStructType('S', [
new Field('x', makePrimitiveType(Kind.Int8), true),
new Field('b', makePrimitiveType(Kind.Bool), false)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let v = new Struct(typeRef, typeDef, {x: 42, b: true});
w.writeTopLevel(typeRef, v);
let v = new Struct(type, typeDef, {x: 42, b: true});
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, true, 42, true], w.array);
v = new Struct(typeRef, typeDef, {b: true});
v = new Struct(type, typeDef, {b: true});
w = new JsonArrayWriter(ms);
w.writeTopLevel(typeRef, v);
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, false, true], w.array);
});
@@ -147,24 +147,24 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let typeDef = makeStructTypeRef('S', [
new Field('x', makePrimitiveTypeRef(Kind.Int8), false)
let typeDef = makeStructType('S', [
new Field('x', makePrimitiveType(Kind.Int8), false)
], [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('s', makePrimitiveTypeRef(Kind.String), false)
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('s', makePrimitiveType(Kind.String), false)
]);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let v = new Struct(typeRef, typeDef, {x: 42, s: 'hi'});
w.writeTopLevel(typeRef, v);
let v = new Struct(type, typeDef, {x: 42, s: 'hi'});
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, 42, 1, 'hi'], w.array);
v = new Struct(typeRef, typeDef, {x: 42, b: true});
v = new Struct(type, typeDef, {x: 42, b: true});
w = new JsonArrayWriter(ms);
w.writeTopLevel(typeRef, v);
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, 42, 0, true], w.array);
});
@@ -172,21 +172,21 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let typeDef = makeStructTypeRef('S', [
new Field('l', makeCompoundTypeRef(Kind.List, makePrimitiveTypeRef(Kind.String)), false)
let typeDef = makeStructType('S', [
new Field('l', makeCompoundType(Kind.List, makePrimitiveType(Kind.String)), false)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let v = new Struct(typeRef, typeDef, {l: ['a', 'b']});
w.writeTopLevel(typeRef, v);
let v = new Struct(type, typeDef, {l: ['a', 'b']});
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, ['a', 'b']], w.array);
v = new Struct(typeRef, typeDef, {l: []});
v = new Struct(type, typeDef, {l: []});
w = new JsonArrayWriter(ms);
w.writeTopLevel(typeRef, v);
w.writeTopLevel(type, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 0, []], w.array);
});
@@ -194,21 +194,21 @@ suite('Encode', () => {
let ms = new MemoryStore();
let w = new JsonArrayWriter(ms);
let s2TypeDef = makeStructTypeRef('S2', [
new Field('x', makePrimitiveTypeRef(Kind.Int32), false)
let s2TypeDef = makeStructType('S2', [
new Field('x', makePrimitiveType(Kind.Int32), false)
], []);
let sTypeDef = makeStructTypeRef('S', [
new Field('s', makeTypeRef(new Ref(), 0), false)
let sTypeDef = makeStructType('S', [
new Field('s', makeType(new Ref(), 0), false)
], []);
let pkg = new Package([s2TypeDef, sTypeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let s2TypeRef = makeTypeRef(pkgRef, 0);
let sTypeRef = makeTypeRef(pkgRef, 1);
let s2Type = makeType(pkgRef, 0);
let sType = makeType(pkgRef, 1);
let v = new Struct(sTypeRef, sTypeDef, {s: new Struct(s2TypeRef, s2TypeDef, {x: 42})});
w.writeTopLevel(sTypeRef, v);
let v = new Struct(sType, sTypeDef, {s: new Struct(s2Type, s2TypeDef, {x: 42})});
w.writeTopLevel(sType, v);
assert.deepEqual([Kind.Unresolved, pkgRef.toString(), 1, 42], w.array);
});
});
js2/src/get_ref.js
+3 -3
View File
@@ -4,13 +4,13 @@
import Ref from './ref.js';
import {encodeNomsValue} from './encode.js';
import {TypeRef} from './type_ref.js';
import {Type} from './type.js';
export function getRef(v: any, t: TypeRef): Ref {
export function getRef(v: any, t: Type): Ref {
return encodeNomsValue(v, t, null).ref;
}
export function ensureRef(r: ?Ref, v: any, t: TypeRef): Ref {
export function ensureRef(r: ?Ref, v: any, t: Type): Ref {
if (r !== null && r !== undefined && !r.isEmpty()) {
return r;
}
js2/src/get_ref_test.js
+3 -3
View File
@@ -7,14 +7,14 @@ import Ref from './ref.js';
import {assert} from 'chai';
import {ensureRef, getRef} from './get_ref.js';
import {Kind} from './noms_kind.js';
import {makePrimitiveTypeRef} from './type_ref.js';
import {makePrimitiveType} from './type.js';
import {suite, test} from 'mocha';
suite('get ref', () => {
test('getRef', () => {
let input = `t [${Kind.Bool},false]`;
let ref = Chunk.fromString(input).ref;
let tr = makePrimitiveTypeRef(Kind.Bool);
let tr = makePrimitiveType(Kind.Bool);
let actual = getRef(false, tr);
assert.strictEqual(ref.toString(), actual.toString());
@@ -22,7 +22,7 @@ suite('get ref', () => {
test('ensureRef', () => {
let r: ?Ref = null;
let tr = makePrimitiveTypeRef(Kind.Bool);
let tr = makePrimitiveType(Kind.Bool);
r = ensureRef(r, false, tr);
assert.isNotNull(r);
assert.strictEqual(r, ensureRef(r, false, tr));
js2/src/noms.js
+2 -2
View File
@@ -8,7 +8,7 @@ import MemoryStore from './memory_store.js';
import Ref from './ref.js';
import {encodeNomsValue} from './encode.js';
import {readValue} from './decode.js';
import {TypeRef} from './type_ref.js';
import {Type} from './type.js';
import Struct from './struct.js';
export {
@@ -19,5 +19,5 @@ export {
readValue,
Ref,
Struct,
TypeRef
Type
};
js2/src/noms_kind.js
+3 -3
View File
@@ -25,7 +25,7 @@ export const Kind: {
Set: NomsKind,
Enum: NomsKind,
Struct: NomsKind,
TypeRef: NomsKind,
Type: NomsKind,
Unresolved: NomsKind,
Package: NomsKind
} = {
@@ -49,7 +49,7 @@ export const Kind: {
Set: 17,
Enum: 18,
Struct: 19,
TypeRef: 20,
Type: 20,
Unresolved: 21,
Package: 22
};
@@ -70,7 +70,7 @@ export function isPrimitiveKind(k: NomsKind): boolean {
case Kind.String:
case Kind.Blob:
case Kind.Value:
case Kind.TypeRef:
case Kind.Type:
case Kind.Package:
return true;
default:
js2/src/package.js
+6 -6
View File
@@ -6,25 +6,25 @@ import Ref from './ref.js';
import type {ChunkStore} from './chunk_store.js';
import {ensureRef} from './get_ref.js';
import {invariant} from './assert.js';
import {packageTypeRef, TypeRef} from './type_ref.js';
import {packageType, Type} from './type.js';
import {readValue} from './decode.js';
class Package {
types: Array<TypeRef>;
types: Array<Type>;
dependencies: Array<Ref>;
_ref: Ref;
constructor(types: Array<TypeRef>, dependencies: Array<Ref>) {
constructor(types: Array<Type>, dependencies: Array<Ref>) {
this.types = types;
this.dependencies = dependencies;
}
get ref(): Ref {
return this._ref = ensureRef(this._ref, this, this.typeRef);
return this._ref = ensureRef(this._ref, this, this.type);
}
get typeRef(): TypeRef {
return packageTypeRef;
get type(): Type {
return packageType;
}
}
js2/src/struct.js
+8 -8
View File
@@ -4,22 +4,22 @@
import Ref from './ref.js';
import {ensureRef} from './get_ref.js';
import {Field, StructDesc, TypeRef} from './type_ref.js';
import {Field, StructDesc, Type} from './type.js';
import {invariant, notNull} from './assert.js';
type StructData = {[key: string]: any};
export default class Struct {
typeRef: TypeRef;
type: Type;
desc: StructDesc;
unionField: ?Field;
_data: StructData;
typeDef: TypeRef;
typeDef: Type;
_ref: Ref;
constructor(typeRef: TypeRef, typeDef: TypeRef, data: StructData) {
this.typeRef = typeRef;
constructor(type: Type, typeDef: Type, data: StructData) {
this.type = type;
this.typeDef = typeDef;
let desc = typeDef.desc;
@@ -31,7 +31,7 @@ export default class Struct {
}
get ref(): Ref {
return this._ref = ensureRef(this._ref, this, this.typeRef);
return this._ref = ensureRef(this._ref, this, this.type);
}
equals(other: Struct): boolean {
@@ -72,7 +72,7 @@ export default class Struct {
});
data[key] = value;
return new Struct(this.typeRef, this.typeDef, data);
return new Struct(this.type, this.typeDef, data);
}
forEach(callbackfn: (value: any, index: string, field?: Field) => void): void {
@@ -106,7 +106,7 @@ function findField(desc: StructDesc, name: string): [?Field, boolean] {
}
function validate(s: Struct): ?Field {
// TODO: Validate field values match field typeRefs.
// TODO: Validate field values match field types.
let data = s._data;
let dataCount = Object.keys(data).length;
s.desc.fields.forEach(field => {
js2/src/struct_test.js
+35 -35
View File
@@ -4,7 +4,7 @@
import Struct from './struct.js';
import {assert} from 'chai';
import {Field, makePrimitiveTypeRef, makeStructTypeRef, makeTypeRef} from './type_ref.js';
import {Field, makePrimitiveType, makeStructType, makeType} from './type.js';
import {Kind} from './noms_kind.js';
import {notNull} from './assert.js';
import {Package, registerPackage} from './package.js';
@@ -12,19 +12,19 @@ import {suite, test} from 'mocha';
suite('Struct', () => {
test('equals', () => {
let typeDef = makeStructTypeRef('S1', [
new Field('x', makePrimitiveTypeRef(Kind.Bool), false),
new Field('o', makePrimitiveTypeRef(Kind.String), true)
let typeDef = makeStructType('S1', [
new Field('x', makePrimitiveType(Kind.Bool), false),
new Field('o', makePrimitiveType(Kind.String), true)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let data1 = {x: true};
let s1 = new Struct(typeRef, typeDef, data1);
let s2 = new Struct(typeRef, typeDef, data1);
let s1 = new Struct(type, typeDef, data1);
let s2 = new Struct(type, typeDef, data1);
assert.isTrue(s1.equals(s2));
});
@@ -32,63 +32,63 @@ suite('Struct', () => {
// TODO: 'struct chunks', 'chunks optional', 'chunks union'
test('new', () => {
let typeDef = makeStructTypeRef('S2', [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('o', makePrimitiveTypeRef(Kind.String), true)
let typeDef = makeStructType('S2', [
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('o', makePrimitiveType(Kind.String), true)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let s1 = new Struct(typeRef, typeDef, {b: true});
let s1 = new Struct(type, typeDef, {b: true});
assert.strictEqual(true, s1.get('b'));
assert.isFalse(s1.has('o'));
assert.isFalse(s1.has('x'));
let s2 = new Struct(typeRef, typeDef, {b: false, o: 'hi'});
let s2 = new Struct(type, typeDef, {b: false, o: 'hi'});
assert.strictEqual(false, s2.get('b'));
assert.isTrue(s2.has('o'));
assert.strictEqual('hi', s2.get('o'));
assert.throws(() => {
new Struct(typeRef, typeDef, {o: 'hi'}); // missing required field
new Struct(type, typeDef, {o: 'hi'}); // missing required field
});
assert.throws(() => {
new Struct(typeRef, typeDef, {x: 'hi'}); // unknown field
new Struct(type, typeDef, {x: 'hi'}); // unknown field
});
});
test('new union', () => {
let typeDef = makeStructTypeRef('S3', [], [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('o', makePrimitiveTypeRef(Kind.String), false)
let typeDef = makeStructType('S3', [], [
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('o', makePrimitiveType(Kind.String), false)
]);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let s1 = new Struct(typeRef, typeDef, {b: true});
let s1 = new Struct(type, typeDef, {b: true});
assert.strictEqual(true, s1.get('b'));
assert.isFalse(s1.has('o'));
});
test('struct set', () => {
let typeDef = makeStructTypeRef('S3', [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('o', makePrimitiveTypeRef(Kind.String), true)
let typeDef = makeStructType('S3', [
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('o', makePrimitiveType(Kind.String), true)
], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let s1 = new Struct(typeRef, typeDef, {b: true});
let s1 = new Struct(type, typeDef, {b: true});
let s2 = s1.set('b', false);
// TODO: assert throws on set wrong type
@@ -101,16 +101,16 @@ suite('Struct', () => {
});
test('struct forEach', () => {
let field1 = new Field('b', makePrimitiveTypeRef(Kind.Bool), false);
let field2 = new Field('o', makePrimitiveTypeRef(Kind.String), false);
let typeDef = makeStructTypeRef('S3', [field1, field2], []);
let field1 = new Field('b', makePrimitiveType(Kind.Bool), false);
let field2 = new Field('o', makePrimitiveType(Kind.String), false);
let typeDef = makeStructType('S3', [field1, field2], []);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let s1 = new Struct(typeRef, typeDef, {b: true, o: 'hi'});
let s1 = new Struct(type, typeDef, {b: true, o: 'hi'});
let expect = [true, 'b', field1, 'hi', 'o', field2];
s1.forEach((v, k, f) => {
assert.strictEqual(expect.shift(), v);
@@ -120,17 +120,17 @@ suite('Struct', () => {
});
test('struct set union', () => {
let typeDef = makeStructTypeRef('S3', [], [
new Field('b', makePrimitiveTypeRef(Kind.Bool), false),
new Field('s', makePrimitiveTypeRef(Kind.String), false)
let typeDef = makeStructType('S3', [], [
new Field('b', makePrimitiveType(Kind.Bool), false),
new Field('s', makePrimitiveType(Kind.String), false)
]);
let pkg = new Package([typeDef], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let typeRef = makeTypeRef(pkgRef, 0);
let type = makeType(pkgRef, 0);
let s1 = new Struct(typeRef, typeDef, {b: true});
let s1 = new Struct(type, typeDef, {b: true});
assert.strictEqual(0, s1.unionIndex);
assert.strictEqual(true, s1.get(notNull(s1.unionField).name));
assert.isFalse(s1.has('s'));
js2/src/type_ref.js → js2/src/type.js
+30 -30
View File
@@ -46,9 +46,9 @@ class UnresolvedDesc {
class CompoundDesc {
kind: NomsKind;
elemTypes: Array<TypeRef>;
elemTypes: Array<Type>;
constructor(kind: NomsKind, elemTypes: Array<TypeRef>) {
constructor(kind: NomsKind, elemTypes: Array<Type>) {
this.kind = kind;
this.elemTypes = elemTypes;
}
@@ -113,10 +113,10 @@ class StructDesc {
class Field {
name: string;
t: TypeRef;
t: Type;
optional: boolean;
constructor(name: string, t: TypeRef, optional: boolean) {
constructor(name: string, t: Type, optional: boolean) {
this.name = name;
this.t = t;
this.optional = optional;
@@ -127,7 +127,7 @@ class Field {
}
}
class TypeRef {
class Type {
_namespace: string;
_name: string;
_desc: TypeDesc;
@@ -140,14 +140,14 @@ class TypeRef {
}
get ref(): Ref {
return this._ref = ensureRef(this._ref, this, this.typeRef);
return this._ref = ensureRef(this._ref, this, this.type);
}
get typeRef(): TypeRef {
return typeRefTypeRef;
get type(): Type {
return typeType;
}
equals(other: TypeRef): boolean {
equals(other: Type): boolean {
return this.ref.equals(other.ref);
}
@@ -198,15 +198,15 @@ class TypeRef {
return out;
}
get elemTypes(): Array<TypeRef> {
get elemTypes(): Array<Type> {
invariant(this._desc instanceof CompoundDesc);
return this._desc.elemTypes;
}
}
function buildType(n: string, desc: TypeDesc): TypeRef {
function buildType(n: string, desc: TypeDesc): Type {
if (isPrimitiveKind(desc.kind)) {
return new TypeRef(n, '', desc);
return new Type(n, '', desc);
}
switch (desc.kind) {
@@ -217,18 +217,18 @@ function buildType(n: string, desc: TypeDesc): TypeRef {
case Kind.Enum:
case Kind.Struct:
case Kind.Unresolved:
return new TypeRef(n, '', desc);
return new Type(n, '', desc);
default:
throw new Error('Unrecognized Kind: ' + desc.kind);
}
}
function makePrimitiveTypeRef(k: NomsKind): TypeRef {
function makePrimitiveType(k: NomsKind): Type {
return buildType('', new PrimitiveDesc(k));
}
function makeCompoundTypeRef(k: NomsKind, ...elemTypes: Array<TypeRef>): TypeRef {
function makeCompoundType(k: NomsKind, ...elemTypes: Array<Type>): Type {
if (elemTypes.length === 1) {
invariant(k !== Kind.Map, 'Map requires 2 element types');
} else {
@@ -239,33 +239,33 @@ function makeCompoundTypeRef(k: NomsKind, ...elemTypes: Array<TypeRef>): TypeRef
return buildType('', new CompoundDesc(k, elemTypes));
}
function makeStructTypeRef(name: string, fields: Array<Field>, choices: Array<Field>): TypeRef {
function makeStructType(name: string, fields: Array<Field>, choices: Array<Field>): Type {
return buildType(name, new StructDesc(fields, choices));
}
function makeTypeRef(pkgRef: Ref, ordinal: number): TypeRef {
return new TypeRef('', '', new UnresolvedDesc(pkgRef, ordinal));
function makeType(pkgRef: Ref, ordinal: number): Type {
return new Type('', '', new UnresolvedDesc(pkgRef, ordinal));
}
function makeUnresolvedTypeRef(namespace: string, name: string): TypeRef {
return new TypeRef(name, namespace, new UnresolvedDesc(new Ref(), -1));
function makeUnresolvedType(namespace: string, name: string): Type {
return new Type(name, namespace, new UnresolvedDesc(new Ref(), -1));
}
let typeRefTypeRef = makePrimitiveTypeRef(Kind.TypeRef);
let packageTypeRef = makePrimitiveTypeRef(Kind.Package);
let typeType = makePrimitiveType(Kind.Type);
let packageType = makePrimitiveType(Kind.Package);
export {
CompoundDesc,
Field,
makeCompoundTypeRef,
makePrimitiveTypeRef,
makeStructTypeRef,
makeTypeRef,
makeUnresolvedTypeRef,
makeCompoundType,
makePrimitiveType,
makeStructType,
makeType,
makeUnresolvedType,
PrimitiveDesc,
StructDesc,
TypeRef,
typeRefTypeRef,
packageTypeRef,
Type,
typeType,
packageType,
UnresolvedDesc
};
js2/src/type_ref_test.js → js2/src/type_test.js
+20 -20
View File
@@ -5,39 +5,39 @@
import MemoryStore from './memory_store.js';
import Ref from './ref.js';
import {assert} from 'chai';
import {Field, makeCompoundTypeRef, makePrimitiveTypeRef, makeStructTypeRef, makeTypeRef} from './type_ref.js';
import {Field, makeCompoundType, makePrimitiveType, makeStructType, makeType} from './type.js';
import {Kind} from './noms_kind.js';
import {Package, registerPackage} from './package.js';
import {readValue} from './decode.js';
import {suite, test} from 'mocha';
import {writeValue} from './encode.js';
suite('Type Ref', () => {
suite('Type', () => {
test('types', async () => {
let ms = new MemoryStore();
let boolType = makePrimitiveTypeRef(Kind.Bool);
let uint8Type = makePrimitiveTypeRef(Kind.UInt8);
let stringType = makePrimitiveTypeRef(Kind.String);
let mapType = makeCompoundTypeRef(Kind.Map, stringType, uint8Type);
let setType = makeCompoundTypeRef(Kind.Set, stringType);
let mahType = makeStructTypeRef('MahStruct', [
let boolType = makePrimitiveType(Kind.Bool);
let uint8Type = makePrimitiveType(Kind.UInt8);
let stringType = makePrimitiveType(Kind.String);
let mapType = makeCompoundType(Kind.Map, stringType, uint8Type);
let setType = makeCompoundType(Kind.Set, stringType);
let mahType = makeStructType('MahStruct', [
new Field('Field1', stringType, false),
new Field('Field2', boolType, true)
], []);
let otherType = makeStructTypeRef('MahOtherStruct', [], [
let otherType = makeStructType('MahOtherStruct', [], [
new Field('StructField', mahType, false),
new Field('StringField', stringType, false)
]);
let pkgRef = Ref.parse('sha1-0123456789abcdef0123456789abcdef01234567');
let trType = makeTypeRef(pkgRef, 42);
let trType = makeType(pkgRef, 42);
let otherRef = writeValue(otherType, otherType.typeRef, ms);
let mapRef = writeValue(mapType, mapType.typeRef, ms);
let setRef = writeValue(setType, setType.typeRef, ms);
let mahRef = writeValue(mahType, mahType.typeRef, ms);
let trRef = writeValue(trType, trType.typeRef, ms);
let otherRef = writeValue(otherType, otherType.type, ms);
let mapRef = writeValue(mapType, mapType.type, ms);
let setRef = writeValue(setType, setType.type, ms);
let mahRef = writeValue(mahType, mahType.type, ms);
let trRef = writeValue(trType, trType.type, ms);
assert.isTrue(otherType.equals(await readValue(otherRef, ms)));
assert.isTrue(mapType.equals(await readValue(mapRef, ms)));
@@ -49,12 +49,12 @@ suite('Type Ref', () => {
test('type with pkgRef', async () => {
let ms = new MemoryStore();
let pkg = new Package([makePrimitiveTypeRef(Kind.Float64)], []);
let pkg = new Package([makePrimitiveType(Kind.Float64)], []);
registerPackage(pkg);
let pkgRef = pkg.ref;
let unresolvedType = makeTypeRef(pkgRef, 42);
let unresolvedRef = writeValue(unresolvedType, unresolvedType.typeRef, ms);
let unresolvedType = makeType(pkgRef, 42);
let unresolvedRef = writeValue(unresolvedType, unresolvedType.type, ms);
let v = await readValue(unresolvedRef, ms);
assert.isNotNull(v);
@@ -62,7 +62,7 @@ suite('Type Ref', () => {
assert.isNotNull(p);
});
test('typeRefTypeRef', () => {
assert.isTrue(makePrimitiveTypeRef(Kind.Bool).typeRef.equals(makePrimitiveTypeRef(Kind.TypeRef)));
test('type Type', () => {
assert.isTrue(makePrimitiveType(Kind.Bool).type.equals(makePrimitiveType(Kind.Type)));
});
});