fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-14 07:21:30 +00:00
Code Issues Projects Releases Wiki Activity

Implement optional type parameters (#360)

Browse Source 
* Add a NATIVE<T> macro type to simplify use of a native WebAssembly type
* Add default type parameters for internal helpers for explicit loads and stores
* Unify loadUnsafe/loadUnsafeWithOffset etc. into one
* Renamed loadUnsafe etc. into just LOAD, like a macro
* Implement parsing of index signatures, but ignore them, for properly linting code
* Refactor TypedArray<T> to use macros
This commit is contained in:
Daniel Wirtz
2018-12-07 14:33:32 +01:00
committed by GitHub
parent d7f4874650
commit ebae7cbd73
39 changed files with 4698 additions and 4128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
std/assembly/array.ts
View File

@ -3,8 +3,8 @@ import {
HEADER_SIZE,
allocateUnsafe,
reallocateUnsafe,
loadUnsafe,
storeUnsafe
LOAD,
STORE
} from "./internal/arraybuffer";
import {
@ -32,6 +32,7 @@ import {
} from "./builtins";
export class Array<T> {
[key: number]: T; // compatibility only
/* @internal */ buffer_: ArrayBuffer;
/* @internal */ length_: i32;
@ -74,7 +75,7 @@ export class Array<T> {
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (!callbackfn(loadUnsafe<T,T>(buffer, index), index, this)) return false;
if (!callbackfn(LOAD<T>(buffer, index), index, this)) return false;
}
return true;
}
@ -82,7 +83,7 @@ export class Array<T> {
findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (predicate(loadUnsafe<T,T>(buffer, index), index, this)) return index;
if (predicate(LOAD<T>(buffer, index), index, this)) return index;
}
return -1;
}
@ -91,13 +92,13 @@ export class Array<T> {
private __get(index: i32): T {
var buffer = this.buffer_;
return <u32>index < <u32>(buffer.byteLength >>> alignof<T>())
? loadUnsafe<T,T>(buffer, index)
? LOAD<T>(buffer, index)
: <T>unreachable();
}
@operator("{}")
private __unchecked_get(index: i32): T {
return loadUnsafe<T,T>(this.buffer_, index);
return LOAD<T>(this.buffer_, index);
}
@operator("[]=")
@ -111,13 +112,13 @@ export class Array<T> {
this.buffer_ = buffer;
this.length_ = index + 1;
}
storeUnsafe<T,T>(buffer, index, value);
STORE<T>(buffer, index, value);
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
}
@operator("{}=")
private __unchecked_set(index: i32, value: T): void {
storeUnsafe<T,T>(this.buffer_, index, value);
STORE<T>(this.buffer_, index, value);
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
}
@ -138,7 +139,7 @@ export class Array<T> {
}
} else {
for (; start < end; ++start) {
storeUnsafe<T,T>(buffer, start, value);
STORE<T>(buffer, start, value);
}
}
return this;
@ -155,7 +156,7 @@ export class Array<T> {
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
var buffer = this.buffer_;
while (fromIndex < length) {
if (loadUnsafe<T,T>(buffer, fromIndex) == searchElement) return fromIndex;
if (LOAD<T>(buffer, fromIndex) == searchElement) return fromIndex;
++fromIndex;
}
return -1;
@ -168,7 +169,7 @@ export class Array<T> {
else if (fromIndex >= length) fromIndex = length - 1;
var buffer = this.buffer_;
while (fromIndex >= 0) { // ^
if (loadUnsafe<T,T>(buffer, fromIndex) == searchElement) return fromIndex;
if (LOAD<T>(buffer, fromIndex) == searchElement) return fromIndex;
--fromIndex;
}
return -1;
@ -186,7 +187,7 @@ export class Array<T> {
this.buffer_ = buffer;
}
this.length_ = newLength;
storeUnsafe<T,T>(buffer, length, element);
STORE<T>(buffer, length, element);
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(element)); // tslint:disable-line
return newLength;
}
@ -228,7 +229,7 @@ export class Array<T> {
from += count - 1;
to += count - 1;
while (count) {
storeUnsafe<T,T>(buffer, to, loadUnsafe<T,T>(buffer, from));
STORE<T>(buffer, to, LOAD<T>(buffer, from));
--from, --to, --count;
}
} else {
@ -244,7 +245,7 @@ export class Array<T> {
pop(): T {
var length = this.length_;
if (length < 1) throw new RangeError("Array is empty");
var element = loadUnsafe<T,T>(this.buffer_, --length);
var element = LOAD<T>(this.buffer_, --length);
this.length_ = length;
return element;
}
@ -252,7 +253,7 @@ export class Array<T> {
forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
callbackfn(loadUnsafe<T,T>(buffer, index), index, this);
callbackfn(LOAD<T>(buffer, index), index, this);
}
}
@ -262,7 +263,7 @@ export class Array<T> {
var result = new Array<U>(length);
var resultBuffer = result.buffer_;
for (let index = 0; index < length && index < this.length_; ++index) {
storeUnsafe<U,U>(resultBuffer, index, callbackfn(loadUnsafe<T,T>(buffer, index), index, this));
STORE<U>(resultBuffer, index, callbackfn(LOAD<T>(buffer, index), index, this));
}
return result;
}
@ -272,7 +273,7 @@ export class Array<T> {
var length = this.length_;
var result = new Array<T>();
for (let index = 0; index < length && index < this.length_; ++index) {
let value = loadUnsafe<T,T>(buffer, index);
let value = LOAD<T>(buffer, index);
if (callbackfn(value, index, this)) result.push(value);
}
return result;
@ -285,7 +286,7 @@ export class Array<T> {
var accum = initialValue;
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
accum = callbackfn(accum, loadUnsafe<T,T>(buffer, index), index, this);
accum = callbackfn(accum, LOAD<T>(buffer, index), index, this);
}
return accum;
}
@ -297,7 +298,7 @@ export class Array<T> {
var accum = initialValue;
var buffer = this.buffer_;
for (let index: i32 = this.length_ - 1; index >= 0; --index) {
accum = callbackfn(accum, loadUnsafe<T,T>(buffer, index), index, this);
accum = callbackfn(accum, LOAD<T>(buffer, index), index, this);
}
return accum;
}
@ -306,14 +307,14 @@ export class Array<T> {
var length = this.length_;
if (length < 1) throw new RangeError("Array is empty");
var buffer = this.buffer_;
var element = loadUnsafe<T,T>(buffer, 0);
var element = LOAD<T>(buffer, 0);
var lastIndex = length - 1;
memory.copy(
changetype<usize>(buffer) + HEADER_SIZE,
changetype<usize>(buffer) + HEADER_SIZE + sizeof<T>(),
<usize>lastIndex << alignof<T>()
);
storeUnsafe<T,T>(buffer, lastIndex, <T>null);
STORE<T>(buffer, lastIndex, <T>null);
this.length_ = lastIndex;
return element;
}
@ -321,7 +322,7 @@ export class Array<T> {
some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
var buffer = this.buffer_;
for (let index = 0, toIndex = this.length_; index < toIndex && index < this.length_; ++index) {
if (callbackfn(loadUnsafe<T,T>(buffer, index), index, this)) return true;
if (callbackfn(LOAD<T>(buffer, index), index, this)) return true;
}
return false;
}
@ -343,7 +344,7 @@ export class Array<T> {
changetype<usize>(buffer) + HEADER_SIZE,
<usize>(capacity - 1) << alignof<T>()
);
storeUnsafe<T,T>(buffer, 0, element);
STORE<T>(buffer, 0, element);
this.length_ = newLength;
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(element)); // tslint:disable-line
return newLength;
@ -396,9 +397,9 @@ export class Array<T> {
reverse(): Array<T> {
var buffer = this.buffer_;
for (let front = 0, back = this.length_ - 1; front < back; ++front, --back) {
let temp = loadUnsafe<T,T>(buffer, front);
storeUnsafe<T,T>(buffer, front, loadUnsafe<T,T>(buffer, back));
storeUnsafe<T,T>(buffer, back, temp);
let temp = LOAD<T>(buffer, front);
STORE<T>(buffer, front, LOAD<T>(buffer, back));
STORE<T>(buffer, back, temp);
}
return this;
}
@ -411,11 +412,11 @@ export class Array<T> {
if (length <= 1) return this;
var buffer = this.buffer_;
if (length == 2) {
let a = loadUnsafe<T,T>(buffer, 1); // a = arr[1]
let b = loadUnsafe<T,T>(buffer, 0); // b = arr[0]
let a = LOAD<T>(buffer, 1); // a = arr[1]
let b = LOAD<T>(buffer, 0); // b = arr[0]
if (comparator(a, b) < 0) {
storeUnsafe<T,T>(buffer, 1, b); // arr[1] = b;
storeUnsafe<T,T>(buffer, 0, a); // arr[0] = a;
STORE<T>(buffer, 1, b); // arr[1] = b;
STORE<T>(buffer, 0, a); // arr[0] = a;
}
return this;
}
@ -444,14 +445,14 @@ export class Array<T> {
var hasSeparator = sepLen != 0;
if (value instanceof bool) {
if (!lastIndex) {
return select<string>("true", "false", loadUnsafe<T,bool>(buffer, 0));
return select<string>("true", "false", LOAD<T,bool>(buffer, 0));
}
let valueLen = 5; // max possible length of element len("false")
let estLen = (valueLen + sepLen) * lastIndex + valueLen;
let result = allocateUnsafeString(estLen);
let offset = 0;
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,bool>(buffer, i);
value = LOAD<T,bool>(buffer, i);
valueLen = 4 + <i32>(!value);
copyUnsafeString(result, offset, select<string>("true", "false", value), 0, valueLen);
offset += valueLen;
@ -460,7 +461,7 @@ export class Array<T> {
offset += sepLen;
}
}
value = loadUnsafe<T,bool>(buffer, lastIndex);
value = LOAD<T,bool>(buffer, lastIndex);
valueLen = 4 + <i32>(!value);
copyUnsafeString(result, offset, select<string>("true", "false", value), 0, valueLen);
offset += valueLen;
@ -473,21 +474,21 @@ export class Array<T> {
return out;
} else if (isInteger<T>()) {
if (!lastIndex) {
return changetype<string>(itoa<T>(loadUnsafe<T,T>(buffer, 0)));
return changetype<string>(itoa<T>(LOAD<T>(buffer, 0)));
}
const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + <i32>isSigned<T>();
let estLen = (valueLen + sepLen) * lastIndex + valueLen;
let result = allocateUnsafeString(estLen);
let offset = 0;
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,T>(buffer, i);
value = LOAD<T>(buffer, i);
offset += itoa_stream<T>(changetype<usize>(result), offset, value);
if (hasSeparator) {
copyUnsafeString(result, offset, separator, 0, sepLen);
offset += sepLen;
}
}
value = loadUnsafe<T,T>(buffer, lastIndex);
value = LOAD<T>(buffer, lastIndex);
offset += itoa_stream<T>(changetype<usize>(result), offset, value);
let out = result;
if (estLen > offset) {
@ -497,21 +498,21 @@ export class Array<T> {
return out;
} else if (isFloat<T>()) {
if (!lastIndex) {
return changetype<string>(dtoa(loadUnsafe<T,f64>(buffer, 0)));
return changetype<string>(dtoa(LOAD<T,f64>(buffer, 0)));
}
const valueLen = MAX_DOUBLE_LENGTH;
let estLen = (valueLen + sepLen) * lastIndex + valueLen;
let result = allocateUnsafeString(estLen);
let offset = 0;
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,f64>(buffer, i);
value = LOAD<T,f64>(buffer, i);
offset += dtoa_stream(changetype<usize>(result), offset, value);
if (hasSeparator) {
copyUnsafeString(result, offset, separator, 0, sepLen);
offset += sepLen;
}
}
value = loadUnsafe<T,f64>(buffer, lastIndex);
value = LOAD<T,f64>(buffer, lastIndex);
offset += dtoa_stream(changetype<usize>(result), offset, value);
let out = result;
if (estLen > offset) {
@ -521,16 +522,16 @@ export class Array<T> {
return out;
} else if (isString<T>()) {
if (!lastIndex) {
return loadUnsafe<T,string>(buffer, 0);
return LOAD<string>(buffer, 0);
}
let estLen = 0;
for (let i = 0, len = lastIndex + 1; i < len; ++i) {
estLen += loadUnsafe<T,string>(buffer, i).length;
estLen += LOAD<string>(buffer, i).length;
}
let offset = 0;
let result = allocateUnsafeString(estLen + sepLen * lastIndex);
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,String>(buffer, i);
value = LOAD<string>(buffer, i);
if (value) {
let valueLen = value.length; // tslint:disable-line:no-unsafe-any
copyUnsafeString(result, offset, value, 0, valueLen); // tslint:disable-line:no-unsafe-any
@ -541,7 +542,7 @@ export class Array<T> {
offset += sepLen;
}
}
value = loadUnsafe<T,String>(buffer, lastIndex);
value = LOAD<string>(buffer, lastIndex);
if (value) {
let valueLen = value.length; // tslint:disable-line:no-unsafe-any
copyUnsafeString(result, offset, value, 0, valueLen); // tslint:disable-line:no-unsafe-any
@ -549,15 +550,15 @@ export class Array<T> {
return result;
} else if (isArray<T>()) {
if (!lastIndex) {
value = loadUnsafe<T,T>(buffer, 0);
value = LOAD<T>(buffer, 0);
return value ? value.join(separator) : ""; // tslint:disable-line:no-unsafe-any
}
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,T>(buffer, i);
value = LOAD<T>(buffer, i);
if (value) result += value.join(separator); // tslint:disable-line:no-unsafe-any
if (hasSeparator) result += separator;
}
value = loadUnsafe<T,T>(buffer, lastIndex);
value = LOAD<T>(buffer, lastIndex);
if (value) result += value.join(separator); // tslint:disable-line:no-unsafe-any
return result;
} else if (isReference<T>()) { // References
@ -567,7 +568,7 @@ export class Array<T> {
let result = allocateUnsafeString(estLen);
let offset = 0;
for (let i = 0; i < lastIndex; ++i) {
value = loadUnsafe<T,T>(buffer, i);
value = LOAD<T>(buffer, i);
if (value) {
copyUnsafeString(result, offset, changetype<String>("[object Object]"), 0, valueLen);
offset += valueLen;
@ -577,7 +578,7 @@ export class Array<T> {
offset += sepLen;
}
}
if (loadUnsafe<T,T>(buffer, lastIndex)) {
if (LOAD<T>(buffer, lastIndex)) {
copyUnsafeString(result, offset, changetype<String>("[object Object]"), 0, valueLen);
offset += valueLen;
}