issue_owner_repo
listlengths 2
2
| issue_body
stringlengths 0
261k
⌀ | issue_title
stringlengths 1
925
| issue_comments_url
stringlengths 56
81
| issue_comments_count
int64 0
2.5k
| issue_created_at
stringlengths 20
20
| issue_updated_at
stringlengths 20
20
| issue_html_url
stringlengths 37
62
| issue_github_id
int64 387k
2.46B
| issue_number
int64 1
127k
|
|---|---|---|---|---|---|---|---|---|---|
[
"chakra-core",
"ChakraCore"
] |
There is already a good set of JsCreate* functions, but it would be good to have new ones for the new ES6 container types:
* Map
* Set
* WeakMap
* WeakSet
/cc @liminzhu @digitalinfinity
|
Add JsCreate* functions for ES6 container types
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2882/comments
| 3 |
2017-04-27T22:24:55Z
|
2018-05-16T22:21:19Z
|
https://github.com/chakra-core/ChakraCore/issues/2882
| 224,930,194 | 2,882 |
[
"chakra-core",
"ChakraCore"
] |
We use non-temporal stores in js_memset_zero_nontemporal() to zero pages in the background. To guarantee memory serialization, we should use an SFENCE at the end of the code.
|
Non-temporal stores should be followed by SFENCE
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2881/comments
| 0 |
2017-04-27T20:14:35Z
|
2017-05-02T03:42:43Z
|
https://github.com/chakra-core/ChakraCore/issues/2881
| 224,900,173 | 2,881 |
[
"chakra-core",
"ChakraCore"
] |
While I realize that each thread would rightly require its own runtime context, I notice that many of the Jsrt functions require a context to already be set before calling... this is not itself a big problem, but what would happen if in one thread I set the current context before calling one jsrt function, but then after setting the context but before the function could actually execute, the thread gets preempted by another thread which may set a different context before invoking a jsrt function of its own on that thread... when control returns to the original thread, since the context is not passed as a parameter to most jsrt functions, would the first thread be trying to execute the function with the second thread's context? If so, how can this be mitigated?
|
How thread-safe is the jsrt api?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2879/comments
| 8 |
2017-04-27T17:09:17Z
|
2017-05-17T21:31:19Z
|
https://github.com/chakra-core/ChakraCore/issues/2879
| 224,852,426 | 2,879 |
[
"chakra-core",
"ChakraCore"
] |
See checks that ran for https://github.com/Microsoft/ChakraCore/pull/2826, in particular: https://ci.dot.net/job/Microsoft_ChakraCore/job/release_1.3/job/ubuntu_check_eol_prtest/1835/console
All of that tasks that ran should have had `release_1.4` in their URL, but the Style Check tasks were `release_1.3`.
* Verify that the style check tasks are correctly generated for `release_1.4`
* Track down why the wrong tasks were triggered
Not sure if this has caused any problems because these tasks are all the same and the diff (for files affected by the change) is taken by comparing against `master` (in the future this behavior will be changed to diff against the target branch (https://github.com/Microsoft/ChakraCore/issues/962)), but I would be suspicious about whether whatever the problem is could cause problems in the future or affect more complex non-style checks.
|
Jenkins Style Checks (EOL Check, Tab Check, Copyright Check) running under task for incorrect branch
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2877/comments
| 0 |
2017-04-26T21:04:24Z
|
2017-05-01T19:47:27Z
|
https://github.com/chakra-core/ChakraCore/issues/2877
| 224,598,876 | 2,877 |
[
"chakra-core",
"ChakraCore"
] |
Regardless of the application, the stack trace at termination always looks like this, when running an application that is linked with ChakraCore using valgrind:
```
Out of Memory
==10928==
==10928== Process terminating with default action of signal 6 (SIGABRT)
==10928== at 0x61943F8: raise (in /lib64/libc-2.23.so)
==10928== by 0x6195FF9: abort (in /lib64/libc-2.23.so)
==10928== by 0x4EC9DB: Memory::X64WriteBarrierCardTableManager::Initialize()
==10928== by 0x42100C: _GLOBAL__sub_I_RecyclerWriteBarrierManager.cpp
==10928== by 0xBB9D1C: __libc_csu_init
==10928== by 0x617F75E: (below main) (in /lib64/libc-2.23.so)
```
This is happening on a Linux x64 system with 32G of ram.
Some of the exact addresses may vary, depending on which branch of ChakraCore I link to, but the result is always the same. Even a very tiny application that does nothing more than read user input and execute the javascript in a REPL will crash on startup when running it with valgrind. The applications do not appear to use very much memory otherwise, and operate as intended outside of Valgrind, but I do require a method of using a tool such as this for programs that I write.
I've been troubleshooting things on my end as much as I know how, but it appears to me that the problem lies in Chakacore's memory usage at startup.
|
Applications using libchakracore crash in Valgrind with OOM
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2873/comments
| 3 |
2017-04-26T14:23:28Z
|
2017-05-25T15:02:31Z
|
https://github.com/chakra-core/ChakraCore/issues/2873
| 224,485,800 | 2,873 |
[
"chakra-core",
"ChakraCore"
] |
Replacing the `a` in `var` with a unicode escape of ASCII `a` (`\u0061`) yields `v\u0061r` in place of this keyword.
```
## Source
print((function () { v\u0061r a = 1; return a; })())
┌─────────────┬──────────────────────────────────────────────────────────┐
│ d8 │ │
│ node │ SyntaxError: Keyword must not contain escaped characters │
├─────────────┼──────────────────────────────────────────────────────────┤
│ sm │ │
│ │ SyntaxError: var is an invalid identifier: │
├─────────────┼──────────────────────────────────────────────────────────┤
│ node-ch │ │
│ ch-2.0 │ SyntaxError: Syntax error │
│ ch-master │ │
└─────────────┴──────────────────────────────────────────────────────────┘
```
IMO: SM's error is confusing, and our current error is completely useless. v8 has a good error here.
/cc @curtisman @bterlson
---
Some info to help investigation (line numbers as of commit 3656c42cd750fcd7883e10159a919309abed0046):
With the above repro, try putting a breakpoint in `lib\Parser\kwd-swtch.h` line 395 (code follows):
```
case 'v':
if (identifyKwds)
```
Step through from here and find out how the error is decided, and then determine how we would emit a better error message without hurting performance.
It appears we ultimately return `JsErrorScriptCompile` from `lib\Jsrt\Jsrt.cpp` line 2993:
```
if (scriptFunction == nullptr)
{
PERFORM_JSRT_TTD_RECORD_ACTION_NOT_IMPLEMENTED(scriptContext);
HandleScriptCompileError(scriptContext, &se);
return JsErrorScriptCompile;
}
```
Basically we know at that point that the script failed to compile, and that's all the information we have. We would need to return a more specific JsError to improve the error message.
|
Poor error message for unicode escapes in keywords
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2872/comments
| 14 |
2017-04-25T21:40:42Z
|
2024-07-02T15:09:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2872
| 224,280,510 | 2,872 |
[
"chakra-core",
"ChakraCore"
] |
See: https://github.com/Microsoft/ChakraCore/issues/319
This will allow us to increase test coverage in cases that are not fundamentally broken while waiting for additional features like spoofing timezone for the ch process.
|
Test: split non-timezone-specific tests to their own test files
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2869/comments
| 0 |
2017-04-24T21:44:00Z
|
2018-05-16T22:15:35Z
|
https://github.com/chakra-core/ChakraCore/issues/2869
| 223,960,256 | 2,869 |
[
"chakra-core",
"ChakraCore"
] |
Consider the following code:
```js
function update(isAdd, value, then) {
let fn = isAdd
? (x) => x + value
: (x) => x - value;
return then(fn);
}
function multiply(value) {
return fn => x => fn(x) * value;
}
function divide(value) {
return fn => x => fn(x) / value;
}
const fn1 = update(true, 10, divide(5));
const fn2 = update(false, 13, multiply(2));
function run(x) {
return fn1(x) + fn2(x);
}
```
The function `run()` is obviously compile-time inlineable, because all function calls can be cleanly flattened. V8 in Chrome 58 flattens the whole chain perfectly, yielding identical performance between:
```js
target = run(target);
```
and the equivalent manually-flattened version:
```js
target = (target + 10)/5 + (target - 13)*2;
```
Here is the test in jsperf, ready to run: https://jsperf.com/functional-composition-with-inlining
Firefox shows roughly a 10% performance drop for the functional version, as compared to the baseline. Safari sits somewhere between Chrome and Firefox.
Edge performance on the same test is shockingly bad:
|
Inlining seems to lack sufficient sophistication for non-trivial functional composition use cases
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2866/comments
| 6 |
2017-04-22T20:22:05Z
|
2019-06-07T19:00:25Z
|
https://github.com/chakra-core/ChakraCore/issues/2866
| 223,590,369 | 2,866 |
[
"chakra-core",
"ChakraCore"
] |
You can use JsCreateSymbol to create a Symbol from a String, but how can you get the string back that was used to create a Symbol? In particular, I notice that calling JsConvertValueToString with a symbol as the first argument does not produce the desired result (I get a JsErrorScriptException).
|
[proposed label: Question] How do you get back the string that created a symbol?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2864/comments
| 0 |
2017-04-22T04:02:38Z
|
2017-04-24T01:03:20Z
|
https://github.com/chakra-core/ChakraCore/issues/2864
| 223,538,289 | 2,864 |
[
"chakra-core",
"ChakraCore"
] |
The C++ compiler team is currently doing daily RWC (Read World Code) testing which includes Chakra.
We are also working with internal partners and the community to fix source issues exposed by "/permissive-".
The option isn’t finalized yet (we plan to add some large impact features into it in the incoming VS update), so we don’t suggest to adopt it yet.
In the meantime, we want to address these source issues as early as possible so that the community can adopt it when it is finalized.
We discover some source issues in Chakra when we build it with "/permissive-".
Here is the issue:
src\lib\runtime\Library/JavascriptLibrary.h(770): error C4596: 'CreatePromiseAllResolveElementFunction_TTD': illegal qualified name in member declaration
Js::RecyclableObject* JavascriptLibrary::CreatePromiseAllResolveElementFunction_TTD(Js::JavascriptPromiseCapability* capabilities, uint32 index, Js::JavascriptPromiseAllResolveElementFunctionRemainingElementsWrapper* wrapper, Js::RecyclableObject* values, bool alreadyCalled);
The member function declaration above is inside the class ‘JavascriptLibrary’ and the prefix 'JavascriptLibrary::' before the member function name isn’t allowed. The fix is to remove it.
|
Issues found when building with MSVC + /permissive-
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2862/comments
| 5 |
2017-04-21T22:09:17Z
|
2017-05-04T19:07:45Z
|
https://github.com/chakra-core/ChakraCore/issues/2862
| 223,510,072 | 2,862 |
[
"chakra-core",
"ChakraCore"
] |
Hi.
I am in the need of a JS engine, and as ChakraCore looks simpler to embed than google's one (I need the debug features), I tried to build an application with it.
The build of the library itself did perform well. But when I try the Hello World [Sample](https://github.com/Microsoft/Chakra-Samples/tree/master/ChakraCore%20Samples/Hello%20World/Linux_OSX_Shared), I get:
`../out/Release/libChakraCore.so : undefined reference to « Js::WasmLibrary::WasmDeferredParseEntryPoint(Js::RecyclableObject*, Js::CallInfo, ...) »`
I succeeded to build a program in « static mode » or with the 1.4 branch.
Build informations:
- ChakraCore Version: the master branch (bfc4da44e3f9560c72bf87aad9f63b8fcdd5cd16)
- OS: Debian testing
- kernel: 4.9.0-2-amd64 (SMP Debian 4.9.18-1)
- arch: amd64
- target: Release Shared
- main libraries/tools:
component | version/info
-------------- | --------------
libc6 | 2.24-9
libstdc++6 | 6.3.0-12
gcc-6 | 6.3.0-12
|
Linux build is missing symbols as it is impossible to link to the shared library
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2859/comments
| 7 |
2017-04-21T16:31:22Z
|
2017-04-26T18:44:42Z
|
https://github.com/chakra-core/ChakraCore/issues/2859
| 223,434,489 | 2,859 |
[
"chakra-core",
"ChakraCore"
] |
Hi.
First of all, thank you for an awesome piece of software. :)
My use case requires the Chakracore runtime to call back into the host code every once in a while( could be based on number of executed instructions or elapsed time), in order to run cpu use checks, etc. I could use DisableExecution, but it is too big a weapon for my needs. :D
Is there a way to make this happen inside Chakracore? I do have the option of instrumenting the javascript code with esprima or similar and add the instructions myself. However, there could be a vastly more efficient way to do this inside the runtime itself. What are your thoughts on this?
Regards.
|
Interrupt callback
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2858/comments
| 6 |
2017-04-21T16:00:29Z
|
2017-06-07T01:39:03Z
|
https://github.com/chakra-core/ChakraCore/issues/2858
| 223,426,862 | 2,858 |
[
"chakra-core",
"ChakraCore"
] |
I am seeing this issue in Microsoft Edge 38.14393.1066.0, Microsoft EdgeHTML 14.14393 on a Windows 10 Pro Version 1607 machine. The OS Build is 14393.1066. The Processor is AMD Athlon(tm) || X2 B24, 3.0GHz.
The problem does not occur on Edge/Win Enterprise, Edge/Win Home or another Edge/Win Pro machine (same version/build as Win Pro above, different Processor: Pentium((R) Dual-Core CPU [email protected] 3.07 GHz).
There is a codepen here: http://codepen.io/ejg/pen/YVyJBv
On the problem machine, when I click the submit Button the endOffset of the range is 5 and the parentNode is the span. When I click the submit Link, the endOffset of the range is 1 and the parentNode is the body.
All the other machines, for both button and link, the endOffset is 5 and the parentNode is the span.
|
Click event on link changes window.getSelection() object
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2857/comments
| 3 |
2017-04-21T15:49:04Z
|
2017-07-21T14:34:53Z
|
https://github.com/chakra-core/ChakraCore/issues/2857
| 223,423,742 | 2,857 |
[
"chakra-core",
"ChakraCore"
] |
In case `JsRun` script throws a JavascriptException, `JsHasException` returns false. However, `JsGetAndClearException` returns the exception object if called.
The reason is try/catch block after callFunction calls `JsGetAndClearException` and records the exception object.
|
JsHasException doesn't work
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2844/comments
| 1 |
2017-04-17T15:26:07Z
|
2017-04-19T16:51:16Z
|
https://github.com/chakra-core/ChakraCore/issues/2844
| 222,154,838 | 2,844 |
[
"chakra-core",
"ChakraCore"
] |
Repro:
```javascript
// bug.js
WScript.LoadModule('import * as foo0 from "b.js";');
WScript.LoadModule('import * as foo1 from "c.js";');
WScript.LoadModule('import * as foo2 from "b.js"; var childObj = Object.create(foo2);');
```
```javascript
// b.js
// empty
```
```javascript
// c.js
export * from 'a.js';
```
```javascript
// a.js
// empty
```
```
>ch -es6module bug.js
ASSERTION 112444: (E:\sdxgit3\inetcore\jscript\core\lib\Runtime\Types\SimpleDictionaryTypeHandler.cpp, line 2436) this->singletonInstance == nullptr || localSingletonInstance == instance
Failure: (this->singletonInstance == nullptr || localSingletonInstance == instance)
FATAL ERROR: ch.exe failed due to exception code c0000420
```
|
ModuleNamespace initialization triggers singleton instance assertion
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2840/comments
| 0 |
2017-04-14T20:40:52Z
|
2017-04-14T22:07:53Z
|
https://github.com/chakra-core/ChakraCore/issues/2840
| 221,887,295 | 2,840 |
[
"chakra-core",
"ChakraCore"
] |
AFAIK currently timezone settings are taken from the system settings.
It would be great, if we could specify timezone for specific runtime instance. It's extremely useful in multitenant environments.
|
Please allow timezone setting per runtime instance
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2839/comments
| 1 |
2017-04-14T15:27:57Z
|
2017-04-24T21:41:34Z
|
https://github.com/chakra-core/ChakraCore/issues/2839
| 221,830,989 | 2,839 |
[
"chakra-core",
"ChakraCore"
] |
Currently, Time Travel Debugging requires that the user first record the session, and then replay it. ChakraCore can be used for debugging React Native applications and can also [take advantage of](http://blog.nparashuram.com/2016/08/time-travel-debugging-with-reactnative.html) Time Travel Debugging.
For making this scenario even better, it would be awesome if we could record and replay during the same debug session.
|
[TTD] Support Time Travel Debug Record and Replay in the same session
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2837/comments
| 5 |
2017-04-14T03:06:02Z
|
2018-06-08T02:41:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2837
| 221,731,873 | 2,837 |
[
"chakra-core",
"ChakraCore"
] |
The JSRT overview appears to say that the garbage collector may clean up JsRef's that are on the native application's heap if JsAddRef has not been called for them, but it is not clear to me if the stack that is being referred to is only the javascript runtime stack, or if it includes local variables that are created in C. If it does not include the native stack, then it would seem that JsAddRef and JsRelease bookkeeping needs to be done for any C variables containing a JsRef if one does not want the garbage collector to clean them before the function exits. This does, of course, run somewhat counter to what the documentatoin appears to say about the garbage collector not trying to clean up references on the stack, but I cannot see how it would be able to identify references that were native C local variables. If local C variables are in fact safe from being clearned, how does the garbage collector know not to touch them?
|
[proposed label: Question] Is the native C stack really known to the garbage collection system?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2836/comments
| 5 |
2017-04-13T23:02:43Z
|
2017-04-15T02:54:32Z
|
https://github.com/chakra-core/ChakraCore/issues/2836
| 221,704,181 | 2,836 |
[
"chakra-core",
"ChakraCore"
] |
Change WasmSignature::m_paramSize & m_paramsCount to ArgSlot and put necessary checks to make sure we don't overflow.
Right now, we use uint32 for the number of arguments in wasm, but at some places we cast this w/o checks to ArgSlot (because that's what the rest of the engine uses).
|
WASM - signature param fields type
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2833/comments
| 1 |
2017-04-13T22:08:59Z
|
2017-06-02T06:50:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2833
| 221,695,558 | 2,833 |
[
"chakra-core",
"ChakraCore"
] |
Test case:
```js
Object.defineProperty(this, 'f', {})
eval('{function f() {}}')
print(Object.getOwnPropertyDescriptor(this, 'f').value)
```
ChakraCore outputs the function, whereas three other engines output `undefined`. ChakraCore ignored the fact that the property was non-writable and non-configurable to get this output.
|
ChakraCore allows writing to a non-writable, non-configurable property through Annex B 3.3 edge case
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2828/comments
| 2 |
2017-04-12T11:02:07Z
|
2019-06-07T18:43:13Z
|
https://github.com/chakra-core/ChakraCore/issues/2828
| 221,226,541 | 2,828 |
[
"chakra-core",
"ChakraCore"
] |
Test case:
```js
var {proxy, revoke} = Proxy.revocable({a: 0}, new Proxy({}, {
get(t, pk) {
if (pk === "getOwnPropertyDescriptor")
revoke();
}
}));
Object.keys(proxy);
```
```gdb
0x00007ffff3b80ba5 in Js::JavascriptOperators::GetOwnPropertyDescriptor (obj=0x0, propertyId=739, scriptContext=0x55555589f288, propertyDescriptor=0x7fffffff89c8)
at /home/andre/git/ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp:1227
1227 Assert(obj);
(gdb) bt
#0 0x00007ffff3b80ba5 in Js::JavascriptOperators::GetOwnPropertyDescriptor (obj=0x0, propertyId=739, scriptContext=0x55555589f288, propertyDescriptor=0x7fffffff89c8)
at /home/andre/git/ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp:1227
#1 0x00007ffff3ea0de6 in Js::JavascriptProxy::GetOwnPropertyDescriptor(Js::RecyclableObject*, int, Js::ScriptContext*, Js::PropertyDescriptor*)::$_16::operator()() const (this=0x7fffffff8800)
at /home/andre/git/ChakraCore/lib/Runtime/Library/JavascriptProxy.cpp:1656
#2 0x00007ffff3e9de24 in Js::JavascriptProxy::GetPropertyDescriptorTrap<Js::JavascriptProxy::GetOwnPropertyDescriptor(Js::RecyclableObject*, int, Js::ScriptContext*, Js::PropertyDescriptor*)::$_16, Js::JavascriptProxy::GetOwnPropertyDescriptor(Js::RecyclableObject*, int, Js::ScriptContext*, Js::PropertyDescriptor*)::$_17>(void*, Js::JavascriptProxy::GetOwnPropertyDescriptor(Js::RecyclableObject*, int, Js::ScriptContext*, Js::PropertyDescriptor*)::$_16, Js::JavascriptProxy::GetOwnPropertyDescriptor(Js::RecyclableObject*, int, Js::ScriptContext*, Js::PropertyDescriptor*)::$_17, Js::PropertyDescriptor*, Js::ScriptContext*) (this=0x7ffff0b84870, originalInstance=0x7ffff0b84870, fn=..., getPropertyId=..., resultDescriptor=0x7fffffff89c8, requestContext=0x55555589f288)
at /home/andre/git/ChakraCore/lib/Runtime/Library/JavascriptProxy.cpp:218
#3 0x00007ffff3e96e99 in Js::JavascriptProxy::GetOwnPropertyDescriptor (obj=0x7ffff0b84870, propertyId=739, scriptContext=0x55555589f288, propertyDescriptor=0x7fffffff89c8)
at /home/andre/git/ChakraCore/lib/Runtime/Library/JavascriptProxy.cpp:1659
#4 0x00007ffff3b80d3d in Js::JavascriptOperators::GetOwnPropertyDescriptor (obj=0x7ffff0b84870, propertyId=739, scriptContext=0x55555589f288, propertyDescriptor=0x7fffffff89c8)
at /home/andre/git/ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp:1233
#5 0x00007ffff3b81332 in Js::JavascriptOperators::GetOwnEnumerablePropertyNames (instance=0x7ffff0b84870, scriptContext=0x55555589f288)
at /home/andre/git/ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp:1175
#6 0x00007ffff3e7336e in Js::JavascriptObject::EntryKeys (function=0x7ffff033f480, callInfo=...)
at /home/andre/git/ChakraCore/lib/Runtime/Library/JavascriptObject.cpp:10
....
```
|
Nullptr assertion error/crash in GetOwnPropertyDescriptor with revoked proxy
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2823/comments
| 2 |
2017-04-11T16:13:10Z
|
2017-04-13T16:01:02Z
|
https://github.com/chakra-core/ChakraCore/issues/2823
| 221,004,543 | 2,823 |
[
"chakra-core",
"ChakraCore"
] |
This is based to redirect the main branch Default code IE: account user any access
|
Agree
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2815/comments
| 2 |
2017-04-07T10:14:35Z
|
2017-04-07T19:00:41Z
|
https://github.com/chakra-core/ChakraCore/issues/2815
| 220,171,383 | 2,815 |
[
"chakra-core",
"ChakraCore"
] |
The names sections changed quite a bit since first implementation.
- [Current Design](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#name-section)
- [Change names section to custom section](https://github.com/WebAssembly/design/pull/877)
- [Extend Names section](https://github.com/WebAssembly/design/pull/984)
|
WASM - Names Section
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2811/comments
| 0 |
2017-04-07T01:22:29Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2811
| 220,080,740 | 2,811 |
[
"chakra-core",
"ChakraCore"
] |
Failures (4 tests):
test262/test/annexB/built-ins/Object/prototype/__defineGetter__/getter-non-callable.js: Expected SameValue("5", "0") to be true
test262/test/annexB/built-ins/Object/prototype/__defineGetter__/this-non-obj.js: Expected SameValue("2", "0") to be true
test262/test/annexB/built-ins/Object/prototype/__defineSetter__/setter-non-callable.js: Expected SameValue("5", "0") to be true
test262/test/annexB/built-ins/Object/prototype/__defineSetter__/this-non-obj.js: Expected SameValue("2", "0") to be true
Resources:
https://tc39.github.io/ecma262/#sec-additional-properties-of-the-object.prototype-object
https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__ (step 2.)
https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__ (step 2.)
Analysis:
Should throw error as soon as
2. If IsCallable(setter) is false throw TypeError exception
We wait until after
4. Let key be ? ToPropertyKey(P).
|
test262/annexB: When getter/setter not callable, should not call toString on key because TypeError is thrown first
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2809/comments
| 0 |
2017-04-06T22:21:51Z
|
2017-07-08T01:22:13Z
|
https://github.com/chakra-core/ChakraCore/issues/2809
| 220,050,465 | 2,809 |
[
"chakra-core",
"ChakraCore"
] |
Update definition of exposed functions.
toGMTString currently calls toUTCString internally and we can get rid of the separate definition entirely.
Failures (1 test):
test262/test/annexB/built-ins/Date/prototype/toGMTString/value.js:
Expected SameValue("function toGMTString() { [native code] }", "function toUTCString() { [native code] }") to be true
Resources:
esid: sec-date.prototype.togmtstring
es6id: B.2.4.3
es5id: B.2.6
description: Value of `Date.prototype.toGMTString`
https://tc39.github.io/ecma262/#sec-date.prototype.togmtstring
|
test262/annexB: toGMTString and toUTCString should be the same function object
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2808/comments
| 0 |
2017-04-06T22:19:01Z
|
2017-08-15T22:46:40Z
|
https://github.com/chakra-core/ChakraCore/issues/2808
| 220,049,898 | 2,808 |
[
"chakra-core",
"ChakraCore"
] |
Right now we do a double conversion then convert the double to float. Just convert directly to float32
|
WASM - Int64 to Float32 specific lower implementation (3d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2803/comments
| 0 |
2017-04-06T18:46:26Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2803
| 219,995,482 | 2,803 |
[
"chakra-core",
"ChakraCore"
] |
Do const folding on int64 math opcodes
|
WASM - Int64 const folding (5d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2802/comments
| 0 |
2017-04-06T18:44:07Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2802
| 219,994,832 | 2,802 |
[
"chakra-core",
"ChakraCore"
] |
Make WebAssembly.compile/instantiate really async.
Right now we synchronously compile and instantiate the WebAssembly module and instance. We should queue the job and let the event loop take care of it
|
WASM - Make async apis really async (5d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2801/comments
| 0 |
2017-04-06T18:43:32Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2801
| 219,994,659 | 2,801 |
[
"chakra-core",
"ChakraCore"
] |
Cyclic module imports not function properly:
```javascript
// script.js
WScript.LoadScriptFile('./mod0.js', "module");
```
```javascript
// mod0.js
import './mod1.js';
console.log('mod0');
```
```javascript
// mod1.js
import './mod2.js';
console.log('mod1');
```
```javascript
// mod2.js
import './mod0.js';
console.log('mod2');
```
Expected:
```
>ch -es6module script.js
mod2
mod1
mod0
>
```
Actual:
```
>ch -es6module script.js
>
```
|
ES6module: cyclic imports
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2800/comments
| 0 |
2017-04-06T18:35:03Z
|
2017-04-14T21:54:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2800
| 219,992,236 | 2,800 |
[
"chakra-core",
"ChakraCore"
] |
Make int/int64 dev/rem/trunc checks CSE'able
|
WASM - Math checks cse (3d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2799/comments
| 0 |
2017-04-06T18:33:00Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2799
| 219,991,699 | 2,799 |
[
"chakra-core",
"ChakraCore"
] |
Revive the templatized jit for amd64 and investigate performance gain possibilities
|
WASM - Templatized Jit (3w)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2798/comments
| 0 |
2017-04-06T18:22:15Z
|
2017-04-25T04:25:15Z
|
https://github.com/chakra-core/ChakraCore/issues/2798
| 219,988,748 | 2,798 |
[
"chakra-core",
"ChakraCore"
] |
WebAssembly jitted function per instance to allow hardcoding some elements like immutable globals and memory address
|
WASM - Jit function per instances (2w)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2797/comments
| 0 |
2017-04-06T18:20:22Z
|
2018-02-27T19:40:14Z
|
https://github.com/chakra-core/ChakraCore/issues/2797
| 219,988,201 | 2,797 |
[
"chakra-core",
"ChakraCore"
] |
Verify CrossSite support and security for WebAssembly objects and apis
|
WASM - CrossSite (1w)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2796/comments
| 0 |
2017-04-06T18:19:11Z
|
2017-08-03T22:21:52Z
|
https://github.com/chakra-core/ChakraCore/issues/2796
| 219,987,759 | 2,796 |
[
"chakra-core",
"ChakraCore"
] |
Check String tags for WebAssembly prototypes
https://github.com/WebAssembly/design/pull/944
|
WASM - String tags (4d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2795/comments
| 1 |
2017-04-06T18:18:36Z
|
2017-08-03T22:21:24Z
|
https://github.com/chakra-core/ChakraCore/issues/2795
| 219,987,503 | 2,795 |
[
"chakra-core",
"ChakraCore"
] |
Add support for inlining in WebAssembly
|
WASM - Inlining (2w)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2794/comments
| 0 |
2017-04-06T18:17:50Z
|
2017-09-14T18:32:32Z
|
https://github.com/chakra-core/ChakraCore/issues/2794
| 219,987,160 | 2,794 |
[
"chakra-core",
"ChakraCore"
] |
Validate utf8 strings from binary buffer
https://github.com/WebAssembly/design/pull/1016
|
WASM - utf8 strings (2d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2793/comments
| 0 |
2017-04-06T18:14:04Z
|
2017-05-03T00:18:16Z
|
https://github.com/chakra-core/ChakraCore/issues/2793
| 219,985,640 | 2,793 |
[
"chakra-core",
"ChakraCore"
] |
TTD support for ES6 features are a work in progress. Generators are a larger work item that we want to track independently.
|
TTD unsupported ES6 features -- Generators
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2789/comments
| 5 |
2017-04-06T04:33:20Z
|
2019-06-07T19:00:48Z
|
https://github.com/chakra-core/ChakraCore/issues/2789
| 219,783,995 | 2,789 |
[
"chakra-core",
"ChakraCore"
] |
Unfortunately this isn't something that I've been able to test easily so far, but enabling this test caused Jenkins to flag errors on some platforms. The test is disabled before #2730 by the -simdjs flag, and afterwards by the exclude_xplat tag. Errors include things such as "ceil(NaN) == 0" and end-of-precision differences from the baseline on some values, which may be a result of the wrong print tail end precision rounding flag.
|
XPlat: AsmJs/MathBuiltinsCall.js fails on some linux/osx builds with some flags.
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2788/comments
| 1 |
2017-04-06T02:07:10Z
|
2018-06-06T21:16:26Z
|
https://github.com/chakra-core/ChakraCore/issues/2788
| 219,766,310 | 2,788 |
[
"chakra-core",
"ChakraCore"
] |
https://github.com/mathiasbynens/es-regexp-dotall-flag
See implementation of e.g. `ignoreCase` (`/i`) flag.
FYI @bterlson
|
RegExp: Implement dotall (/s) flag
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2787/comments
| 3 |
2017-04-05T22:52:46Z
|
2018-08-28T01:18:19Z
|
https://github.com/chakra-core/ChakraCore/issues/2787
| 219,738,444 | 2,787 |
[
"chakra-core",
"ChakraCore"
] |
Repro:
```
-WERExceptionSupport -ExtendedErrorStackForTestHost -BaselineMode -forceNative -off:simpleJit -bgJitDelay:0 -dynamicprofileinput:profile.dpl.310 -RecyclerVerifyMark -RecyclerConcurrentStress -VerifyBarrierBit -KeepRecyclerTrackData -ExtendedErrorStackForTestHost test/Bugs/randombug.js
```
Message:
```
Output: (at line 71)
----------------------------
Passed
----------------------------
Expected Output:
----------------------------
arrObj0.length setter
----------------------------
```
|
test-fail: randombug fails on CCRobot slow runs
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2780/comments
| 4 |
2017-04-05T14:00:29Z
|
2017-11-21T08:20:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2780
| 219,592,746 | 2,780 |
[
"chakra-core",
"ChakraCore"
] |
I think this is a bug...
The following code in Chrome, Firefox, etc, will return a currency symbol of 'US$':
```
new Intl.NumberFormat('en-CA', {
style: 'currency',
currencyDisplay: 'symbol',
currency: 'USD'
}).format(65421.45)
```
And it will simply use '$' if the currency is set to 'CAD':
```
new Intl.NumberFormat('en-CA', {
style: 'currency',
currencyDisplay: 'symbol',
currency: 'CAD'
}).format(65421.45)
```
But in Edge (and all versions of IE), both of these examples will return a currency symbol of '$'. It will not return US$ or CA$, no matter the locale or currency used. (Same goes for AUD, HKD, etc.)
Example: https://jsfiddle.net/5wfzk7mf/
|
Intl.NumberFormat currency symbols are inaccurate when dealing with different types of dollars/$.
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2778/comments
| 17 |
2017-04-04T19:58:49Z
|
2017-12-05T19:58:47Z
|
https://github.com/chakra-core/ChakraCore/issues/2778
| 219,365,247 | 2,778 |
[
"chakra-core",
"ChakraCore"
] |
Check int64 constant security encoding
|
WASM - Int64 Constant encoding (3d)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2776/comments
| 0 |
2017-04-03T18:32:31Z
|
2017-05-10T00:32:01Z
|
https://github.com/chakra-core/ChakraCore/issues/2776
| 219,022,214 | 2,776 |
[
"chakra-core",
"ChakraCore"
] |
Implement the response API for browser scenario https://github.com/WebAssembly/design/blob/master/Web.md#additional-web-embedding-api
|
WASM - Response API
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2775/comments
| 0 |
2017-04-03T18:31:24Z
|
2017-05-10T00:53:05Z
|
https://github.com/chakra-core/ChakraCore/issues/2775
| 219,021,952 | 2,775 |
[
"chakra-core",
"ChakraCore"
] |
Make WebAssembly Modules structure clonable
|
WASM - Structure Cloning (3w)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2774/comments
| 0 |
2017-04-03T18:28:53Z
|
2017-05-17T18:25:06Z
|
https://github.com/chakra-core/ChakraCore/issues/2774
| 219,021,322 | 2,774 |
[
"chakra-core",
"ChakraCore"
] |
Add Debugging support for WebAssembly in Edge.
- [ ] Generate [.wat](https://github.com/WebAssembly/design/blob/master/TextFormat.md) text format for debugging
- [ ] Debug in Interpreter
- [ ] Implement Bailouts for debugging (support jitted code while debugging)
- [ ] Use the Names section to generate more friendly text code
|
WASM - Debugging (2m)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2773/comments
| 0 |
2017-04-03T18:24:05Z
|
2017-04-25T04:25:14Z
|
https://github.com/chakra-core/ChakraCore/issues/2773
| 219,020,048 | 2,773 |
[
"chakra-core",
"ChakraCore"
] |
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales
https://tc39.github.io/ecma402/#sec-intl.getcanonicallocales
https://tc39.github.io/ecma402/#sec-canonicalizelocalelist
|
Intl.js: Implement Intl.getCanonicalLocales
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2770/comments
| 0 |
2017-03-31T22:08:20Z
|
2017-09-07T00:06:32Z
|
https://github.com/chakra-core/ChakraCore/issues/2770
| 218,629,198 | 2,770 |
[
"chakra-core",
"ChakraCore"
] |
**Environment:** Windows Server 2012 R2 + VS2017 + Chakra master branch latest revision aeb7117
**Repro steps:**
1. git clone -c core.autocrlf=true https://github.com/microsoft/ChakraCore D:\Chakra\src
2. Open a VS 2015 x86 command prompt and browse to D:\Chakra\src
3. msbuild /m /p:Platform=x86 /p:Configuration=Test Build\Chakra.Core.sln /t:Rebuild
4. pushd test
5. runtests -x86test
**Test "NumberFormatOptionsImplSpecific-Win10.js" run failed as below:**
*** Running test #1 (0): Test Valid Options - Formatting Currency with Significant Digits
Test threw exception: assert.areEqual failed: expected: USD 123 actual: USD 123: currency code: USD
FAILED
*** Running test #2 (1): Test Valid Options - Formatting Percentage with Significant Digits
Test threw exception: assert.areEqual failed: expected: 12,300 % actual: 12,300 %: style: percent
FAILED
Summary of tests: total executed: 2; passed: 0; failed: 2
**This test passed on Win10 but failed on Windows Server 2012 R2**. Could you please take a look at this? Thanks in advance!
|
Test "NumberFormatOptionsImplSpecific-Win10.js" failed on Windows Server 2012 R2
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2769/comments
| 2 |
2017-03-31T06:17:43Z
|
2017-03-31T09:56:18Z
|
https://github.com/chakra-core/ChakraCore/issues/2769
| 218,408,153 | 2,769 |
[
"chakra-core",
"ChakraCore"
] |
repro code:
```js
var keys="";
var x=['a'];
x[100]='b';
// x[1]=undefined; // uncomment this line to get exception
var proxy = new Proxy({b:1,a:2}, {
ownKeys: function() {return x;}
});
for(var key in proxy){ keys += key;}
WScript.Echo(keys);
```
the above code should throw exception instead of output 'ab'
Problem is here:
```c++
template <class Fn>
void GetOwnPropertyKeysHelper(ScriptContext* scriptContext, RecyclableObject* trapResultArray, uint32 len, JavascriptArray* trapResult,
JsUtil::BaseDictionary<Js::PropertyId, bool, ArenaAllocator>& targetToTrapResultMap, Fn fn)
{
Var element;
const PropertyRecord* propertyRecord;
uint32 trapResultIndex = 0;
PropertyId propertyId;
for (uint32 i = 0; i < len; i++)
{
if (!JavascriptOperators::GetItem(trapResultArray, i, &element, scriptContext))
continue; <-- should use undefined in case the item is missing
```
|
proxy ownKeys trap should use undefined for missing items
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2755/comments
| 0 |
2017-03-29T00:36:25Z
|
2017-12-05T18:10:49Z
|
https://github.com/chakra-core/ChakraCore/issues/2755
| 217,732,321 | 2,755 |
[
"chakra-core",
"ChakraCore"
] |
For Strings:
https://tc39.github.io/ecma262/#prod-UnicodeEscapeSequence
https://tc39.github.io/ecma262/#sec-string-literals-static-semantics-early-errors
> It is a Syntax Error if the MV of HexDigits > 0x10FFFF.
For RegExp (where a string literal is used):
https://tc39.github.io/ecma262/#sec-regexp-pattern-flags
>If pattern is supplied using a StringLiteral, the usual escape sequence substitutions are performed before the String is processed by RegExp. If pattern must contain an escape sequence to be recognized by RegExp, any U+005C (REVERSE SOLIDUS) code points must be escaped within the StringLiteral to prevent them being removed when the contents of the StringLiteral are formed.
Hence the above error applies trivially in this case.
---
For RegExp where a RegExp literal is used:
https://tc39.github.io/ecma262/#sec-patterns-static-semantics-early-errors
> It is a Syntax Error if the MV of HexDigits > 0x10FFFF.
We fail to do this.
---
Test case `regexp-u-110000.js`:
```js
console.log(/\u{110000}/u);
```
Console output:
```
> node --version
v7.7.4
> node -pe "/\u{110000}/u"
[eval]:1
/\u{110000}/u
^
SyntaxError: Invalid regular expression: /\u{110000}/: Invalid unicode escape
at [eval]:1:1
at ContextifyScript.Script.runInThisContext (vm.js:23:33)
at Object.runInThisContext (vm.js:95:38)
at Object.<anonymous> ([eval]-wrapper:6:22)
at Module._compile (module.js:571:32)
at Immediate.<anonymous> (bootstrap_node.js:392:29)
at runCallback (timers.js:666:20)
at tryOnImmediate (timers.js:639:5)
at processImmediate [as _immediateCallback] (timers.js:611:5)
> nvs
PATH -= %LOCALAPPDATA%\nvs\node\7.7.4\x64
PATH += %LOCALAPPDATA%\nvs\chakracore-nightly\8.0.0-nightly2017032287ce098018\x64
> node -pe "/\u{110000}/u"
/\u{110000}/u
> node regexp-u-110000.js
/\u{110000}/u
> ch regexp-u-110000.js
/\u{110000}/u
```
Here's a test using UnitTestFramework as well:
`ChakraCore\test\UnifiedRegex\UnicodeEscapeExtended.js`
```js
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");
let tests = [
{
name: "Extended Unicode Escape with out-of-range codepoint should throw",
body: function () {
assert.doesNotThrow(function () { /\u{10FFFF}/u });
assert.throws(function () { /\u{110000}/u }, SyntaxError, "out-of-range codepoint should throw");
}
}
];
testRunner.runTests(tests, { verbose: WScript.Arguments[0] != 'summary' });
```
|
RegExp: /u pattern with \u{HexDigits} production with codepoint >0x10FFFF should throw SyntaxError
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2753/comments
| 4 |
2017-03-28T23:23:56Z
|
2018-06-22T21:53:06Z
|
https://github.com/chakra-core/ChakraCore/issues/2753
| 217,721,427 | 2,753 |
[
"chakra-core",
"ChakraCore"
] |
Redefer parse feature helps in freeing function bodies and getting back the memory. From my experiment on identifying memory usage in `chakracore`, below are 2 things that we should do in order to get more benefit out of redefer parse.
* Perform defer parsing for lambdas, getters and setters
* Ignore `CanDeferParse` flag when trying to redefer. For this to happen above, WI need to be done.
|
Improve memory usage in redefer parse scenario
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2752/comments
| 0 |
2017-03-28T22:59:17Z
|
2017-08-15T21:34:40Z
|
https://github.com/chakra-core/ChakraCore/issues/2752
| 217,717,356 | 2,752 |
[
"chakra-core",
"ChakraCore"
] |
The output given by ChakraCore is `1.00010101100011100100011000001001000100111101(e+63)`, but in three other engines, the correct answer of `1000101011000111001000110000010010001001111010000000000000000000` is provided. The [spec](https://tc39.github.io/ecma262/#sec-tostring-applied-to-the-number-type) states that with *n* (the base-10 exponent) between 0 and 21, the written out version should be used, rather than the exponential version.
|
`1e+19.toString(2)` is displayed exponentially, but should be written out
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2751/comments
| 3 |
2017-03-28T21:38:50Z
|
2017-09-15T03:43:44Z
|
https://github.com/chakra-core/ChakraCore/issues/2751
| 217,700,571 | 2,751 |
[
"chakra-core",
"ChakraCore"
] |
Input:
```js
1.1.toFixed(20);
1.1.toPrecision(21)
```
These should both output `"1.10000000000000008882"`, and do so in other engines. See the loop in step 8 of https://tc39.github.io/ecma262/#sec-number.prototype.tofixed -- The algorithm is different (simpler) than Number.prototype.toString.
|
ChakraCore rounds too nicely for `toFixed` and `toPrecision`
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2750/comments
| 0 |
2017-03-28T21:28:30Z
|
2019-06-07T18:43:05Z
|
https://github.com/chakra-core/ChakraCore/issues/2750
| 217,698,045 | 2,750 |
[
"chakra-core",
"ChakraCore"
] |
Test code
```js
let x = new Uint8Array(16);
ArrayBuffer.transfer(x.buffer);
new DataView(x.buffer);
```
Error message:
```
TypeError: 'this' is not a DataView object
at Global code (/home/littledan/chakracore/test.js:3:1)
```
I would've expected something more like
```
TypeError: DataView: The ArrayBuffer is detached.
at Global code (/home/littledan/chakracore/test.js:3:1)
```
|
Bad error message for DataView constructor detached ArrayBuffer
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2749/comments
| 0 |
2017-03-28T21:23:26Z
|
2017-05-19T17:36:03Z
|
https://github.com/chakra-core/ChakraCore/issues/2749
| 217,696,787 | 2,749 |
[
"chakra-core",
"ChakraCore"
] |
```javascript
var a1 = Array.prototype.constructor.apply(null, new Proxy([1950, 1960, 1970, 1980, 1990, 2000, 2010], {}));
var a2 = new Proxy(new Proxy(new Array(66), {}), {});
var o2 = String.prototype.blink.bind(Object, a1);
Object.setPrototypeOf(a2, o2);
```
When changing prototype of a JavascriptProxy, we call `CrossSite::ForceCrossSiteThunkOnPrototypeChain` which marshals objects on the prototype chain with a `null` scriptContext. Some existing object types do not expect this `null` scriptContext.
(found by external researcher, thanks!)
|
JavascriptProxy CrossSite::ForceCrossSiteThunkOnPrototypeChain null dereference
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2748/comments
| 1 |
2017-03-28T00:27:22Z
|
2017-12-01T18:41:52Z
|
https://github.com/chakra-core/ChakraCore/issues/2748
| 217,413,665 | 2,748 |
[
"chakra-core",
"ChakraCore"
] |
```javascript
class ExternInt16Array extends Int16Array {
static get [Symbol.species]() { return Map;};
};
var m1 = new Map();
var o1 = Object.getPrototypeOf(m1);
Reflect.defineProperty(Map.prototype, "set", o1);
var o2 = new ExternInt16Array(new ArrayBuffer(0x100));
var m2 = new Map(o2);
```
Above repro triggers accessing incomplete Map instance during `JavascriptMap::NewInstance`, resulting in null dereference violation.
(found by external researcher, thanks!)
|
JavascriptMap::NewInstance null deference
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2747/comments
| 0 |
2017-03-28T00:21:24Z
|
2017-07-20T23:15:12Z
|
https://github.com/chakra-core/ChakraCore/issues/2747
| 217,412,834 | 2,747 |
[
"chakra-core",
"ChakraCore"
] |
```javascript
eval("--par=>");
```
Triggers the assertion and null dereference violation on release build.
(found by external researcher, thanks!)
|
Parser::TrackAssignment Assert(ref)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2746/comments
| 0 |
2017-03-28T00:14:11Z
|
2017-07-07T20:51:46Z
|
https://github.com/chakra-core/ChakraCore/issues/2746
| 217,411,845 | 2,746 |
[
"chakra-core",
"ChakraCore"
] |
Hello,
I previously used time travel debugging in visual studio code with the -TTRecord:log option. After installing the latest nightly build, I'm seeing this command is deprecated and I should use --record instead. I run this command and it looks successful, but I have no idea where the logs are being saved to. How can I configure the log directory? I checked the command list in the help menu, but I'm not seeing anything there.
Thank you,
Dan
|
How to specify TTD log location when using --record instead of -TTRecord:[dir]?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2737/comments
| 2 |
2017-03-23T22:14:37Z
|
2017-03-24T00:21:12Z
|
https://github.com/chakra-core/ChakraCore/issues/2737
| 216,588,729 | 2,737 |
[
"chakra-core",
"ChakraCore"
] |
There are a number of ES6 module tests that fail to free memory appropriately. This appears to be due to WScriptJSRT not freeing the source code of modules it loads. The affected tests have been marked as exclude_sanitize_address for now in PR #2730 to allow ASAN CI to be enabled. These tests are:
* moduletest1.js
* moduletest2.js
* module-syntax.js
* module-syntax1.js
* module-functionality.js
* module-syntax.js (force:deferparse)
* module-syntax1.js (force:deferparse)
* module-namespace.js
* test_bug_2645.js
* bug_issue_3076.js
Note: This may be an API issue; an (admittedly cursory) look around the APIs related to JsParseModuleSource didn't reveal an easy way to register a finalize callback.
|
ASAN: Module tests commonly fail to free memory.
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2735/comments
| 4 |
2017-03-23T20:16:02Z
|
2018-06-06T18:56:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2735
| 216,558,571 | 2,735 |
[
"chakra-core",
"ChakraCore"
] |
The debugger tests almost all fail when run in ASAN due to not properly freeing memory. The affected test directories have been marked as exclude_sanitize_address for now in PR #2730 to allow ASAN CI to be enabled. These directories are:
* Debugger
* DebuggerCommon
|
ASAN: Debugger tests commonly fail to free memory
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2734/comments
| 1 |
2017-03-23T20:05:44Z
|
2019-06-07T18:34:37Z
|
https://github.com/chakra-core/ChakraCore/issues/2734
| 216,555,873 | 2,734 |
[
"chakra-core",
"ChakraCore"
] |
Running ASAN on the test/typedarray/transfer.js test reports a memory leak on application exit. The leaked memory is sized exactly the same as the TypedArray in the test. The affected test has been marked as exclude_sanitize_address for now in PR #2730 to allow ASAN CI to be enabled.
|
ASAN: TypedArray transfer can leak memory
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2733/comments
| 1 |
2017-03-23T20:05:28Z
|
2017-09-07T17:55:44Z
|
https://github.com/chakra-core/ChakraCore/issues/2733
| 216,555,800 | 2,733 |
[
"chakra-core",
"ChakraCore"
] |
I am getting poor error information when a script does not compile properly; I do get better error line numbers and information in Edge and Chrome, just not using ChakraCore via .net; can this be improved at all (echo in example below is a delegate to a Console.WriteLine)?
Following code:
```
var x = 0;
var y = 2;
console.log( x + y );
var g = 'this is a little 'test' to see what happens';
echo( g );
```
Gives this error:
`ChakraScriptRunnerScript failed at col: 0, line: 0, because: Expected ';'`
I would expect to see something like I see in Edge:
`Expected ';' test.html (9,28)`
I am using code based on the 'hosting' sample at:
[https://github.com/Microsoft/Chakra-Samples/tree/master/Chakra%20Samples/JSRT%20Win32%20Hosting%20Samples/Edge%20JSRT%20Samples/C%23](url)
My error reporter is:
```
private string ReportScriptException( int firstLineNumber, JavaScriptValue exception )
{
JavaScriptPropertyId sourceName = JavaScriptPropertyId.FromString( "source" );
JavaScriptValue sourceValue = exception.GetProperty( sourceName ) : JavaScriptValue.Invalid;
JavaScriptPropertyId messageName = JavaScriptPropertyId.FromString( "message" );
JavaScriptValue messageValue = exception.GetProperty( messageName ) : JavaScriptValue.Invalid;
JavaScriptPropertyId lineName = JavaScriptPropertyId.FromString( "lineNumber" );
JavaScriptValue lineValue = exception.GetProperty( lineName ) : JavaScriptValue.Invalid;
JavaScriptPropertyId colName = JavaScriptPropertyId.FromString( "col" );
JavaScriptValue colValue = exception.GetProperty( colName ) : JavaScriptValue.Invalid;
JavaScriptPropertyId stackName = JavaScriptPropertyId.FromString( "stack" );
JavaScriptValue stackValue = exception.GetProperty( stackName ) : JavaScriptValue.Invalid;
string source = sourceValue.IsValid && sourceValue.ValueType != JavaScriptValueType.Undefined ? sourceValue.ToString() : string.Empty;
string message = messageValue.IsValid && messageValue.ValueType != JavaScriptValueType.Undefined ? messageValue.ToString() : string.Empty;
string stack = stackValue.IsValid && stackValue.ValueType != JavaScriptValueType.Undefined ? stackValue.ToString() : string.Empty;
double line = lineValue.IsValid && lineValue.ValueType != JavaScriptValueType.Undefined ? lineValue.ToDouble() : string.Empty;
double col = colValue.IsValid && colValue.ValueType != JavaScriptValueType.Undefined ? colValue.ToDouble() : string.Empty;
return $"ChakraScriptRunnerScript failed at col: {col}, line: {line}, because: {message}\r\nStack: {stack}";
```
|
Poor Error Handling
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2731/comments
| 4 |
2017-03-23T14:29:55Z
|
2017-03-23T16:11:02Z
|
https://github.com/chakra-core/ChakraCore/issues/2731
| 216,447,740 | 2,731 |
[
"chakra-core",
"ChakraCore"
] |
Hi, I have a quick question. Has anyone in the open source community taken ChakraCore and integrated it with a GUI for a MacOS browser for Safari and below? Anyone know?
|
ChakraCore-based Browser for MacOS coming soon?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2728/comments
| 2 |
2017-03-22T01:48:48Z
|
2017-05-17T21:31:32Z
|
https://github.com/chakra-core/ChakraCore/issues/2728
| 215,929,779 | 2,728 |
[
"chakra-core",
"ChakraCore"
] |
Proposal is here: https://github.com/tc39/proposal-async-iteration
Basic idea is a combination of an async function and a generator - essentially a generator you can `await` within.
There are already a number of test262 tests and v8 has an implementation we can compare against.
|
Implement Async Generators
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2720/comments
| 21 |
2017-03-20T16:35:32Z
|
2020-12-14T18:36:55Z
|
https://github.com/chakra-core/ChakraCore/issues/2720
| 215,479,506 | 2,720 |
[
"chakra-core",
"ChakraCore"
] |
```js
class Foo {
*foo([x = (function (){ throw new Error() }())]) {
return x;
}
}
var f = new Foo();
f.foo([undefined]);
```
Expected: An error is thrown
Actual: No error is thrown, until calling .next, in which case a different error is thrown (attempting to get Symbol.iterator of a null/undefined object).
Applies to normal generator declarations as well.
|
Generators don't evaluate defaults properly
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2719/comments
| 1 |
2017-03-20T16:23:11Z
|
2017-05-17T22:15:48Z
|
https://github.com/chakra-core/ChakraCore/issues/2719
| 215,475,449 | 2,719 |
[
"chakra-core",
"ChakraCore"
] |
Proposal text: https://github.com/sebmarkbage/ecmascript-rest-spread
Example:
```
let { x , ... y } = { x: 1, y: 2, z: 3 };
console.log(x); // { x: 1 }
console.log(y); // { y: 2, z: 3 }
```
Currently stage 3, will likely get stage 4 soon and will be included in ES2018. Already has hundreds of test262 tests as well.
|
Implement Rest/Spread of Properties
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2718/comments
| 1 |
2017-03-20T16:00:34Z
|
2018-03-05T23:19:48Z
|
https://github.com/chakra-core/ChakraCore/issues/2718
| 215,468,127 | 2,718 |
[
"chakra-core",
"ChakraCore"
] |
Test262 depends on $.detachArrayBuffer which, given an array buffer, detaches is (which is what occurs when the buffer is transferred out of a realm). Creating WScript.detachArrayBuffer or similar will enable us to run a variety of TypedArray/ArrayBuffer test262 tests.
|
Implement ch.exe API to detatch or transfer an array buffer
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2717/comments
| 0 |
2017-03-20T15:41:36Z
|
2019-06-07T18:52:03Z
|
https://github.com/chakra-core/ChakraCore/issues/2717
| 215,461,858 | 2,717 |
[
"chakra-core",
"ChakraCore"
] |
The Agent API enables testing of shared array buffers in console APIs. See test262 docs for [$262.agent](https://github.com/tc39/test262/blob/master/INTERPRETING.md#host-defined-functions). Note that these could be exposed as any shape and adapted by the harness. I'm open to alternatives.
See Also: https://github.com/tc39/test262/pull/839
|
Enable SharedArrayBuffer test262 tests in ch.exe
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2714/comments
| 1 |
2017-03-20T01:54:26Z
|
2018-02-05T17:31:53Z
|
https://github.com/chakra-core/ChakraCore/issues/2714
| 215,315,305 | 2,714 |
[
"chakra-core",
"ChakraCore"
] |
A partial list of intrinsics with non-configurable lengths:
* Every built-in constructor
* `async function foo () {}`
|
The `length` property of numerous built-ins are not configurable but should be
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2713/comments
| 1 |
2017-03-20T01:46:48Z
|
2017-08-29T23:54:13Z
|
https://github.com/chakra-core/ChakraCore/issues/2713
| 215,314,752 | 2,713 |
[
"chakra-core",
"ChakraCore"
] |
Today, we create `DebuggerScope` objects during byte code generation and it stores metadata information that is consumed by debugger and memory profiler. However (at least today) there is no way to get put `Chakracore` into debug mode when it is started under non-debug mode E.g. If `node-chakracore` is running under non-debugger mode, it can never go back to debugger mode. Vice versa if it is in debugger mode using `--debug` flag, we can know before hand and make use of this information whether to populate `DebuggerScope` objects or not.
For memory profilers, in future, when we add Jsrt APIs, we can evaluate if we need to pre-populate this meta data during bytecode generation when chakracore is running in non-debugger mode.
This issue is to investigate what can be done to optimize the working set because of `DebuggerScope` objects.
|
Optimize DebuggerScope objects
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2708/comments
| 0 |
2017-03-17T23:06:17Z
|
2018-05-07T23:30:17Z
|
https://github.com/chakra-core/ChakraCore/issues/2708
| 215,143,364 | 2,708 |
[
"chakra-core",
"ChakraCore"
] |
One of the function expression default param test case is failing after the recent merge.
|
Fix the default param split test case failure
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2707/comments
| 0 |
2017-03-17T19:39:16Z
|
2017-05-19T03:35:36Z
|
https://github.com/chakra-core/ChakraCore/issues/2707
| 215,103,122 | 2,707 |
[
"chakra-core",
"ChakraCore"
] |
This issue is broken only with IE11 EDGE document mode, whereas rest of the documents mode <= 10 works exactly fine.
It’s disturbing as say the web page should be in the latest standards document mode like EDGE and its breaking in that document mode itself. Down-level doc modes were its not recommended works exactly fine, seems to be a regression with IE11.
Calling Function.name on Classes fails if it is called in the order of base class->child. If called in the child->base class order, it succeeds.
Simplified Repro, launch below URL and open F12 console section to observe the output.
https://jsfiddle.net/2so35uf3/1/
Actual:
console.log(Animal.name); // returns Animal in IE11 with EDGE doc mode
console.log(Snake.name); // returns Animal in IE11 with EDGE doc mode
console.log(Horse.name); // returns Animal in IE11 with EDGE doc mode
Actual Output:
Animal
Animal
Animal
Expected Output:
Animal
Snake
Horse
Based on walking the code I don't think that is the problem. This appears to be a flaw in the IE11 JIT.
I'm looking for any advice on how to handle this besides (1) don't use IE11 or (2) don't use Function.name.
Sample:
// Typescript
class Animal {
hello(person: string) {
console.log(`Hello ${person}`);
}
}
class Snake extends Animal {
hello(person: string) {
console.log("I'm a snake");
super.hello(person);
}
}
class Horse extends Animal {
get wow(): string {
return "wow";
}
}
console.log(Animal.name);
console.log(Snake.name);
console.log(Horse.name);
tsc -t ES2015 with produces this JavaScript:
class Animal {
hello(person) {
console.log(`Hello ${person}`);
}
}
class Snake extends Animal {
hello(person) {
console.log("I'm a snake");
super.hello(person);
}
}
class Horse extends Animal {
get wow() {
return "wow";
}
}
console.log(Animal.name);
console.log(Snake.name);
console.log(Horse.name);
This issue is also reported in:
http://stackoverflow.com/questions/42470179/ie11-javascript-behavior-with-polyfilled-function-name
https://social.technet.microsoft.com/Forums/en-US/761d1195-bb1d-4129-a39d-420c304e5b15/ie11-jit-broken-when-using-class-properties?forum=ieitprocurrentver
We know that MS is not working on IE11 fixes considering EDGE, but this is breaking the latest EDGE doc mode itself not the older doc modes in IE11 and we can't live with it like that forever. It would have been okay to not fix if the issue was with the older doc modes like IE10/9, but here the issue is with the latest IE11 EDGE doc mode itself.
Hope this is fixed sooner. Thanks.
|
IE11 broken when using class properties only with the latest/default document mode "Edge" (as named in WinBlue)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2706/comments
| 9 |
2017-03-17T19:32:24Z
|
2017-05-17T21:16:21Z
|
https://github.com/chakra-core/ChakraCore/issues/2706
| 215,101,537 | 2,706 |
[
"chakra-core",
"ChakraCore"
] |
```javascript
// script.js
WScript.LoadScriptFile('mod0.js', "module");
```
```javascript
// mod0.js
import 'mod1a.js';
import 'mod1b.js';
console.log('mod0');
```
```javascript
// mod1a.js
//import 'mod1b.js' // uncomment to repro
console.log("mod1a");
```
```javascript
// mod1b.js
console.log("mod1b");
```
`>ch -es6module script.js`
Expected output
```
mod1a
mod1b
mod0
```
Actual output (with `import 'mod1b.js'` uncommented)
``````
|
ES6 module: multiple imports of same module
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2702/comments
| 0 |
2017-03-17T18:01:23Z
|
2017-03-22T17:43:17Z
|
https://github.com/chakra-core/ChakraCore/issues/2702
| 215,079,599 | 2,702 |
[
"chakra-core",
"ChakraCore"
] |
Command:
```
-WERExceptionSupport -ExtendedErrorStackForTestHost -BaselineMode -maxInterpretCount:1 -maxSimpleJitRunCount:1 -bgjit- -dynamicprofilecache:profile.dpl.2803 -force:deferparse -ES6DefaultArgsSplitScope -args summary -endargs test/es6/default-splitscope.js
```
Output:
----------------------------
ASSERTION 62985: (lib/Runtime/ByteCode/ByteCodeEmitter.cpp, line 4827) scope->HasInnerScopeIndex()
Failure: (scope->HasInnerScopeIndex())
----------------------------
exit code: -4
Details: https://github.com/CCRobot/TestResults/blob/20170317T094556DEBUG_ubuntu/TEST_STEP1_2.md
note: @CCRobot doesn't track this item automatically.
test-id: [7562756e74753a44454255475f7562756e7475]
|
Master: Debug build slow test(s) are failing.
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2701/comments
| 3 |
2017-03-17T14:32:08Z
|
2017-03-20T15:03:51Z
|
https://github.com/chakra-core/ChakraCore/issues/2701
| 215,020,542 | 2,701 |
[
"chakra-core",
"ChakraCore"
] |
Hello,
I cloned the latest version of ChakraCore from git and Have LLVM/Clang 5.0 installed. I built ChakraCore with the following command on Ubuntu 16.04 LTS:
$ ./build.sh --sanitize=address -j
the built was successful and i got ch file, but as soon as i try any of the tests in tests/ directory the ch crash with the following error:
:~/ChakraCore-ASAN/out/Release$ ./ch ../../test/Basics/hello.js
dlopen() failed; dlerror says '/home/mj/ChakraCore-ASAN/out/Release/libChakraCore.so: undefined symbol: __asan_option_detect_stack_use_after_return'
FATAL ERROR: Unable to load /home/mj/ChakraCore-ASAN/out/Release/libChakraCore.so GetLastError=0x7e
=================================================================
==24085==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 16 byte(s) in 1 object(s) allocated from:
#0 0x564d66f78890 in operator new[](unsigned long) (/home/mj/ChakraCore-ASAN/out/Release/ch+0xec890)
#1 0x564d66f7e8e2 in main (/home/mj/ChakraCore-ASAN/out/Release/ch+0xf28e2)
#2 0x7f642bfda82f in __libc_start_main /build/glibc-t3gR2i/glibc-2.23/csu/../csu/libc-start.c:291
Indirect leak of 10 byte(s) in 1 object(s) allocated from:
#0 0x564d66f47148 in __interceptor_malloc (/home/mj/ChakraCore-ASAN/out/Release/ch+0xbb148)
#1 0x564d66f7e95b in main (/home/mj/ChakraCore-ASAN/out/Release/ch+0xf295b)
#2 0x7f642bfda82f in __libc_start_main /build/glibc-t3gR2i/glibc-2.23/csu/../csu/libc-start.c:291
SUMMARY: AddressSanitizer: 26 byte(s) leaked in 2 allocation(s).
Thanks in advance
|
Chakra compiled with ASAN not working (in non-static builds)
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2694/comments
| 11 |
2017-03-16T20:34:02Z
|
2020-05-08T16:47:48Z
|
https://github.com/chakra-core/ChakraCore/issues/2694
| 214,830,014 | 2,694 |
[
"chakra-core",
"ChakraCore"
] |
Jenkins: Add "modern" configuration to run builds under Server 2016 and VS 2017
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2690/comments
| 3 |
2017-03-16T01:50:53Z
|
2018-01-17T23:18:20Z
|
https://github.com/chakra-core/ChakraCore/issues/2690
| 214,576,568 | 2,690 |
|
[
"chakra-core",
"ChakraCore"
] |
Do not emit bytecode when validating WebAssembly module
|
WASM: WebAssembly.validate no bytecode
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2688/comments
| 0 |
2017-03-15T22:13:10Z
|
2017-04-07T00:29:12Z
|
https://github.com/chakra-core/ChakraCore/issues/2688
| 214,542,162 | 2,688 |
[
"chakra-core",
"ChakraCore"
] |
I've found a case where trying to load ES6 modules doesn't work reliable: Most of the time, nothing happens, although the source files are requested from server. Sometimes it does work though, maybe it's some race condition. Here's a test case to reproduce:
http://rawgit.com/herrernst/msedge-es6module-bug/master/index.html
I've tested with the "Microsoft Edge on Win 10 Preview (15.15014)" VM from https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/
|
ES6 modules not working in some cases
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2681/comments
| 2 |
2017-03-15T13:38:10Z
|
2017-03-22T17:43:35Z
|
https://github.com/chakra-core/ChakraCore/issues/2681
| 214,391,275 | 2,681 |
[
"chakra-core",
"ChakraCore"
] |
Claims;
- ChakraCore overall doesn't expect the system calls (i.e. threading) are failing.
- PAL does not do much to mend or provide an interface for it
Things done so far;
- #2630 (fallback) and #2679 (cache) are introduced.
- These two fixes help ChakraCore xplat tests to pass under `ulimit -n 32`
Todo;
- enable testing for limited environment to catch more issues and going forward keep it stable.
- not just `open files -n`, test for `stack size`, `vm` and `max memory`
- check, if we may have similar issues on Windows under such limitations.
|
xplat: Improve problem handling in PAL
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2680/comments
| 2 |
2017-03-15T01:21:25Z
|
2018-06-28T00:07:35Z
|
https://github.com/chakra-core/ChakraCore/issues/2680
| 214,254,530 | 2,680 |
[
"chakra-core",
"ChakraCore"
] |
In `GetCurrentThreadStackLimits` (pal_thread.cpp),
```
#elif HAVE_PTHREAD_GETATTR_NP
status = pthread_getattr_np(currentThreadHandle, &attr);
_ASSERT_MSG(status == 0, "pthread_getattr_np call failed");
#else
# error "Dont know how to get thread attributes on this platform!"
#endif
status = pthread_attr_getstack(&attr, &stackend, &stacksize);
_ASSERT_MSG(status == 0, "pthread_attr_getstack call failed");
void* stackbase = (void*) ((char*) stackend + stacksize);
pthread_attr_destroy(&attr);
```
The code path is problematic when "pthread_getattr_np" fails. It continues to read from invalid `attr` and may return invalid results, and `pthread_attr_destroy` on invalid `attr` can AV.
When it fails with `status != 0`, should bail cleanly.
This is found on a node test on Linux with chakracore debug build: `node test/sequential/test-child-process-emfile.js`. The test intentionally triggers error EMFILE, which causes `pthread_getattr_np` to fail. According to http://man7.org/linux/man-pages/man3/pthread_getattr_np.3.html:
```
In addition, if thread refers to the main thread, then
pthread_getattr_np() can fail because of errors from various
underlying calls: fopen(3), if /proc/self/maps can't be opened; and
getrlimit(2), if the RLIMIT_STACK resource limit is not supported.
```
|
pal: pthread_getattr_np result ignored
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2676/comments
| 8 |
2017-03-13T18:54:03Z
|
2017-03-17T15:58:51Z
|
https://github.com/chakra-core/ChakraCore/issues/2676
| 213,863,772 | 2,676 |
[
"chakra-core",
"ChakraCore"
] |
```js
(() => { super.x }))
```
Expected: Early SyntaxError
Actual: No Error
|
Super should be an error in arrow functions outside classes
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2673/comments
| 3 |
2017-03-10T21:56:48Z
|
2017-05-18T04:42:08Z
|
https://github.com/chakra-core/ChakraCore/issues/2673
| 213,462,565 | 2,673 |
[
"chakra-core",
"ChakraCore"
] |
Testing cross-compiled code using emscripten's pthreads/SharedArrayBuffer mode in Edge on Windows Insider build 15048, I found that code that runs in Firefox and Safari tech previews fails here due to a TypeError being thrown in Atomics.store():
Simplified code:
```
var s = new SharedArrayBuffer(65536);
var u = new Uint32Array(s);
Atomics.store(u, 0, 1234);
```
Live example: https://jsfiddle.net/yejks8ja/
This works in Firefox Developer Edition and Safari Technical Preview, but fails in Edge (requires Experimental JS Features flag on) with "TypeError: The operation is not supported on this typed array type"
|
Atomics.store throws "TypeError: The operation is not supported on this typed array type"
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2672/comments
| 3 |
2017-03-10T21:02:47Z
|
2017-03-13T16:59:47Z
|
https://github.com/chakra-core/ChakraCore/issues/2672
| 213,451,415 | 2,672 |
[
"chakra-core",
"ChakraCore"
] |
Note: all of the text output functions named above are implemented as the same native function, `WScriptJsrt::EchoCallback`, with multiple JS name bindings.
['NO-BREAK SPACE' (U+00A0)](http://www.fileformat.info/info/unicode/char/00a0/index.htm)
becomes
[á 'LATIN SMALL LETTER A WITH GRAVE' (U+00E0)](http://www.fileformat.info/info/unicode/char/00e0/index.htm)
[¡ 'INVERTED EXCLAMATION MARK' (U+00A1)](http://www.fileformat.info/info/unicode/char/00A1/index.htm)
becomes
[í 'LATIN SMALL LETTER I WITH GRAVE' (U+00E1)](http://www.fileformat.info/info/unicode/char/00e0/index.htm)
[– 'EN DASH' (U+2013)](http://www.fileformat.info/info/unicode/char/2013/index.htm)
becomes
[? 'QUESTION MARK' (U+003F)](http://www.fileformat.info/info/unicode/char/003f/index.htm)
Same transformation for [EM-DASH (U+2014)](http://www.fileformat.info/info/unicode/char/2014/index.htm)
Here's a test:
```js
console.log("\u00a0\u00a1\u2013\u2014");
// U+00A0 ( ) no-break space
// U+00A1 (¡) inverted exclamation mark
// U+2014 (—) em dash
// U+2013 (–) en dash
```
Output from ch: `áí??`
Output from node: ` ¡–—` (correct output, so apparently not a problem with conhost on Windows)
From looking at a hex dump of the output, the first two cases are apparently incorrectly rendered as a single byte (since the code point is 0 except the bottom 8 bits, we might be mistakenly interpreting that as a code point which is valid to output as a single byte):
```
> ch test.js | xxd
00000000: a0a1 3f3f 0d0a ..??..
```
Note a0a1 in the first two bytes (the ISO/IEC 8859-1 / Latin-1 / Windows-1252, one-byte encoding of those codepoints, but not a correct UTF-8 encoding), and 3f (`?`) in the second two bytes. Final 2 bytes are CRLF.
```
> node test.js | xxd
00000000: c2a0 c2a1 e280 93e2 8094 0a ...........
```
Note c2a0 and c2a1, the correct UTF-8 encodings of U+00A0 and U+00A1, followed by e28093 and e28094, the correct UTF-8 encodings of U+2013 and U+2014 respectively. (LF line terminator at the end.)
In the latter two cases, I think this is internally converting to `?` as a replacement character for an unknown character.
Discovered when looking into https://github.com/Microsoft/ChakraCore/issues/2656
|
Text output functions (WScript.Echo / console.log / print) corrupt non-ASCII characters on output.
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2670/comments
| 1 |
2017-03-10T19:49:01Z
|
2017-10-18T21:50:52Z
|
https://github.com/chakra-core/ChakraCore/issues/2670
| 213,435,252 | 2,670 |
[
"chakra-core",
"ChakraCore"
] |
Test output includes the following line but is otherwise correct:
`WARNING: DynamicProfileStorage: Dynamic Profile Data corrupted: 'e:\a\_work\2\s\test\unittestframework\unittestframework.js'`
Disabled in https://github.com/Microsoft/ChakraCore/pull/2668
|
Fix and Re-enable flaky test test/es6/proto_disable.js
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2667/comments
| 3 |
2017-03-10T19:15:04Z
|
2019-06-07T18:50:40Z
|
https://github.com/chakra-core/ChakraCore/issues/2667
| 213,427,150 | 2,667 |
[
"chakra-core",
"ChakraCore"
] |
When a `JsModuleRecord` is initialized, the host provides a string representing the normalized specifier for that module. Is there a way to retrieve that information later with only the `JsModuleRecord` handle? I couldn't figure out how to do that with the current APIs.
The parent module gets passed into the `FetchImportedModuleCallback`, so it would greatly simplify the lookup code if that information was exposed somehow. (Right now I'm considering using `JsSetModuleHostInfo` with `JsModuleHostInfoKind_HostDefined`, and storing a string with the path there, but I'm unsure on how to even free these resources later on, since modules don't seem to expose a GC callback function like regular JS objects)
Thanks in advance
|
Fetching normalized specifier from JsModuleRecord?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2662/comments
| 5 |
2017-03-10T01:07:29Z
|
2017-06-07T01:38:57Z
|
https://github.com/chakra-core/ChakraCore/issues/2662
| 213,213,820 | 2,662 |
[
"chakra-core",
"ChakraCore"
] |
In order to provide the best possible development experience, we should improve error messages to call out as much information as possible (which parameter, which field, actual/expected types, etc.) when something goes wrong.
## Sub-issues:
### Fixed
* [x] #424 (fixed)
* [x] #2901
### Poor / difficult to understand messages
* [ ] #434
* [ ] https://github.com/Microsoft/ChakraCore/issues/2872
### Nice-to-have improvements
* [ ] Follow up issue #2411 and PR #2648 (improved by the PR but still needs more work)
|
Improve error messages
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2658/comments
| 7 |
2017-03-09T20:47:59Z
|
2018-05-02T16:01:42Z
|
https://github.com/chakra-core/ChakraCore/issues/2658
| 213,160,587 | 2,658 |
[
"chakra-core",
"ChakraCore"
] |
When analyzing a script, the toString output of a class declaration is wrong if preceded by a unicode character (even in a comment).
Example:
```js
// Evil ndash
// –
console.log(class {});
```
Expected output: `class {}`
Actual output: `g(class`
Browser version: 38.14393.0.0
|
Unicode character breaks ES6 class toString() output
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2656/comments
| 9 |
2017-03-09T15:58:16Z
|
2017-05-16T22:27:42Z
|
https://github.com/chakra-core/ChakraCore/issues/2656
| 213,081,121 | 2,656 |
[
"chakra-core",
"ChakraCore"
] |
#2629 adds x86 and x64 support, but arm encoder requires some additional work to get this working. Right now we don't have arm support for wasm/asm.js, and as an optimization targeted mainly for them, arm support is lower priority.
|
add arm support for folding pattern of a+(b<<pow2) into lea
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2653/comments
| 0 |
2017-03-08T23:16:34Z
|
2018-05-07T22:19:11Z
|
https://github.com/chakra-core/ChakraCore/issues/2653
| 212,886,681 | 2,653 |
[
"chakra-core",
"ChakraCore"
] |
If we have import and export for a module and if that module is exported as namespace object then we unable to find that export from the namespace object.
consider this
**test.js**
```js
WScript.LoadScriptFile("test1.js", "module");
```
**test1.js (R)**
```js
import * as module1 from "module1.js";
function test() {
return module1.simpleExport();
}
console.log(test());
```
**module1.js (D1)**
```js
import * as module2 from "module2.js";
export function simpleExport() { return 'exported'; }
```
**module2.js (D2)**
```js
export function simpleExport() { return 'module2.exported'; }
```
ch -es6module test.js produces
TypeError: Object doesn't support property or method 'simpleExport'
at test (:4:5)
at Anonymous function (:7:1)
at module (:1:1)
|
ES6 module : unable to find an object from imports
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2645/comments
| 1 |
2017-03-06T23:59:09Z
|
2017-03-07T17:22:01Z
|
https://github.com/chakra-core/ChakraCore/issues/2645
| 212,288,790 | 2,645 |
[
"chakra-core",
"ChakraCore"
] |
I just started playing with promises and implemented a simple continuation callback like the one documented in the [JavaScript Runtime Overview](https://github.com/Microsoft/ChakraCore/wiki/JavaScript-Runtime-%28JSRT%29-Overview#promises). While at first everything worked smoothly I quickly ran into cryptic stack traces from inside ChakraCore.
Luckily I've seen those before and I knew that garbage collection might be involved. Adding an `JsAddRef(task, NULL)` into the `PromiseContinuationCallback` paired with a `JsRelase(task, NULL)` inside the while-loop indeed solved the issue.
Now my two questions:
- Is this expected behavior? From my limited understanding it seems like it could be, since nobody else might hold a reference to the task.
- If this is expected behavior, wouldn't it be advisable to include the calls to `JsAddRef` and `JsRelease` into the example?
Thanks a lot!
Daniel
Edit: I was using cb7817bda7e4b265e7a7364641123e20204facfd from 21. January. Haven't tried with a stable or more recent release yet.
|
JSRT: Promises, continuation callback and garbage collection
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2638/comments
| 4 |
2017-03-06T08:15:34Z
|
2017-03-15T22:47:46Z
|
https://github.com/chakra-core/ChakraCore/issues/2638
| 212,051,091 | 2,638 |
[
"chakra-core",
"ChakraCore"
] |
I'm writing a binding generator for C++ <-> ChakraCore. Right now, I'm struggling to support extending native classes from JS-defined classes like so:
```
class JavascriptChildClass extends NativeSuperClass {
constructor() {
super();
}
TestChildMethod() {
console.log("Oops!");
}
}
```
However, when I return the object generated from NativeSuperClass's native constructor, I have to call JsSetPrototype on it in order to properly bind the native class to its JS prototype.
I'd like to attach the prototype of "JavascriptChildClass" instead. Right now, I can't find any way to do that, and so the methods on the child class are lost, i.e., TestChildMethod can't be called.
I can't figure out any way to get JavascriptChildClass's prototype from a native context in order to properly set it when "super" is called. It doesn't seem to be, "callee.prototype", "callee.\_\_proto\_\_", or "arguments[0].\_\_proto\_\_", or anything returned from JsGetPrototype on either callee or arguments[0].
Any ideas? Am I doing this completely incorrectly?
|
Question: Getting the prototype of the caller of "super"?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2635/comments
| 1 |
2017-03-04T01:45:03Z
|
2017-08-22T03:52:13Z
|
https://github.com/chakra-core/ChakraCore/issues/2635
| 211,844,853 | 2,635 |
[
"chakra-core",
"ChakraCore"
] |
Hello folks!
You are doing amazing job with ChakraCore. Particularly time traveling debugger really got me.
I read this piece:
https://github.com/nodejs/node-chakracore/blob/xplat/TTD-README.md
I would love to invite somebody from your team to speak at [ReactiveConf 2017](https://reactiveconf.com), on 26–27 of October in Bratislava.
What do you think?
|
[Question] Speaking at Reactive2017?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2620/comments
| 9 |
2017-03-01T14:58:07Z
|
2017-05-17T21:37:28Z
|
https://github.com/chakra-core/ChakraCore/issues/2620
| 211,105,565 | 2,620 |
[
"chakra-core",
"ChakraCore"
] |
When running `ch -v`, it shows version of `ch` and `chakracore` which is expected. But it doesn't complain if `chakracore` is unavailable to load and just output version of `ch`. Do we need error message to imply that `chakracore` cannot be loaded?
|
"ch -v" doesn't complain even if chakracore cannot be loaded?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2617/comments
| 1 |
2017-03-01T02:19:12Z
|
2018-05-16T22:20:29Z
|
https://github.com/chakra-core/ChakraCore/issues/2617
| 210,960,583 | 2,617 |
[
"chakra-core",
"ChakraCore"
] |
We have a bunch of experimental APIs in JSRT (debugging, module, string-related ones, etc) and we should find an appropriate way to mark them as experimental. An obvious solution is to clarify in documentation, but do we want to do something extra, like hiding them behind a flag which JSRT devs should explicitly flip?
|
Marking experimental JSRT APIs
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2611/comments
| 2 |
2017-02-28T19:53:38Z
|
2018-05-16T22:07:28Z
|
https://github.com/chakra-core/ChakraCore/issues/2611
| 210,887,429 | 2,611 |
[
"chakra-core",
"ChakraCore"
] |
We will ship ChakraCore 2.0 with ICU-57 (optionally). Opening this issue to track ICU-58 compatibility problems.
Checklist;
- `node-chakracore` icu-small version is 58.
- Post-Release2.0; update `--embed-icu` to ICU 58
|
ICU-58: Compatibilty issues and Build Break
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2608/comments
| 1 |
2017-02-27T22:18:22Z
|
2017-03-10T08:18:20Z
|
https://github.com/chakra-core/ChakraCore/issues/2608
| 210,624,943 | 2,608 |
[
"chakra-core",
"ChakraCore"
] |
I'm guessing this is a C vs. C++ type system issue but given that the definition of JsRef is available and defined as void*, the C compiler (at least, LLVM 8.0.0 on OS X 10.12.2, though I believe its part of the C spec) will happily convert void* pointers without complaint (even using -Wall -Werror like I do).
I personally tripped on this when trying to use JsCallFunction which takes a JsValueRef* for the argument list. I happened to miss the `*` in the docs and assumed the args were a JsValueRef that was a JavaScript array (rather than a C array of JsValueRef values). It turns out that due to the void* definition that this doesn't trigger any sort of compiler warning though it does trigger segfaults!
A basic example:
```C
JsValueRef func = get_func();
int argc;
JsValueRef args = get_args(&argc);
JsValueRef result;
// Both of these compile fine
JsCallFunction(func, argv, argc, result);
JsCallFunction(func, &argv, argc, result);
```
|
Consider hiding the definition of JsRef
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2607/comments
| 11 |
2017-02-27T20:24:02Z
|
2018-05-16T22:01:58Z
|
https://github.com/chakra-core/ChakraCore/issues/2607
| 210,596,149 | 2,607 |
[
"chakra-core",
"ChakraCore"
] |
#2401 still happens for expression-body (but not block-body) arrow functions.
Reproduced with Chakra 1.4.0 and 1.4.1 (from the github releases).
```js
// works: block
(({ x }) => {
(() => x)();
})({});
console.log('A done');
// works: block with return (behaviourally equivalent)
(({ x }) => {
return (() => x)();
})({});
console.log('B done');
// fails: expression
(({ x }) =>
(() => x)() // "Use before declaration"
)({});
console.log('C done');
```
|
Expression-body arrow function parameter destructuring "Use before declaration" error when parameter is only used in an inner function
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2606/comments
| 4 |
2017-02-27T18:58:31Z
|
2017-09-08T17:18:28Z
|
https://github.com/chakra-core/ChakraCore/issues/2606
| 210,573,957 | 2,606 |
[
"chakra-core",
"ChakraCore"
] |
Hello,
Not sure if this is the best place to ask this (is there a forum for chakra)?
I have a problem with the limitation of only having the 1st interface projected to Javascript. I would like to know if there are any workarounds / methods of solving it.
I have around 20 classes I want to access in Javascript. These 20 classes inherit from a BaseModel, which contains code that are important and used by all 20 classes. Below is a simple example:
```
public class Category : BaseModel
{
public string Title {get;set;}
public string Description {get;set;}
}
public class Item : BaseModel
{
public string Title {get;set;}
public string Price {get;set;}
}
public class BaseModel : INotifyPropertyChanged, IParentableViewModel
{
//Some Important Methods that are shared between around 20 Models
}
```
If I want to access it in Javascript, I would have to create BaseModel for ALL 20 of the classes. This is because Javascript can only see the properties / methods of the 1st Interface. So then my code becomes something like:
```
public class CategoryBaseModel : ICategoryModel, INotifyPropertyChanged, IParentableViewModel
{
//Important Methods gets duplicated between CategoryBaseModel and ItemBaseModel making it harder to maintain
}
public class ItemBaseModel : IItemModel, INotifyPropertyChanged, IParentableViewModel
{
//Important Methods gets duplicated between CategoryBaseModel and ItemBaseModel making it harder to maintain
}
```
Which becomes hard to maintain, especially since I have around 20 methods.
I am looking if I can override the setter for Javascript but not sure how to do it. The idea is this:
```
//I want to override something like this.
//whenever I call category.someProperty = someValue; in Javascript, it goes through this.
//When it goes through this, I can then call the SetProperty method for unknown properties in the interface
public bool JavaScriptPropertySet(object, propertyName, Value)
{
if(object.hasProperty(propertyName))
{
//Set PropertyName
}
else
{
object.setProperty(propertyName, Value);
}
}
```
And then I can define my classes to be simpler like this:
```
public interface IBaseViewModel
{
string Title {get;set;}
void SetProperty(propertyName, Value);
}
public class BaseModel : IBaseViewModel, INotifyPropertyChanged, IParentableViewModel
{
//important methods
public void SetProperty(propertyName, Value)
{
SetPropertyInternal(propertyName, Value);
}
public virtual void SetPropertyInternal(propertyName, Value)
{
}
}
public class Category : BaseModel
{
public override void SetPropertyInternal(propertyName, Value)
{
if(propertyName == 'description')
this.description = Value;
}
}
```
Is there such a way?
Thank you
|
Overcome 1 Interface limitation for projected classes to Javascript?
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2605/comments
| 0 |
2017-02-27T02:55:45Z
|
2017-05-24T15:05:00Z
|
https://github.com/chakra-core/ChakraCore/issues/2605
| 210,375,761 | 2,605 |
[
"chakra-core",
"ChakraCore"
] |
```js
Intl.Collator('generic');
```
gives following error.
```cmd
RangeError: Locale 'generic' is not well-formed
at Global code (e:\temp\ic.js:1:1)
```
This is happening because `Windows.globlalization.dll` [here](https://github.com/Microsoft/ChakraCore/blob/master/lib/Runtime/Base/WindowsGlobalizationAdapter.cpp#L363) returns false and `Intl.js` [here](https://github.com/Microsoft/ChakraCore/blob/master/lib/Runtime/Library/InJavascript/Intl.js#L289) throws. I tried debugging and it is the code inside `Bcp47Langs.dll` that returns it false. May be because it treats `'generic'` as special tag and so call it as not well-formed. I didn't notice anything special about `'generic'` in spec. Also this works in Edge, so might worth investigating why it doesn't work in `ch.exe`. This breaks `node-chakracore` while running `eslint` rules.
|
Intl.Collator('generic') fails
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2604/comments
| 4 |
2017-02-26T00:58:52Z
|
2017-11-08T00:48:22Z
|
https://github.com/chakra-core/ChakraCore/issues/2604
| 210,274,507 | 2,604 |
[
"chakra-core",
"ChakraCore"
] |
In an attempt to write some unit tests for #2581 I hit a slight snag. The native tests that test the JSRT api is driven by a windows only build.
I managed to get the driver to compile, this took a few #defines and an update to catch.hpp. This could probably be improved with a bit more work and getting pal included. I ran into a few macro redefinitions with `charkacore.h` though. Also I had to use libc++ as the version of stdlib++ doesn't seem to support some of the features that are needed by catch. I would need to look on linux to see what happens here.
The other problem is the rather liberal use of windows only jsrt functions. E.g.
```
REQUIRE(JsGetPropertyNameFromId(name1, &name) == JsNoError);
REQUIRE(JsPointerToString(_u("value1"), wcslen(_u("value1")), &value1) == JsNoError);
```
My suggestion is rewrite these to use `JsCopyString` etc. If their is still a need to test JsPointerToString this can be done with platform specific test files. If I head down this path would this be ok?
cc: @digitalinfinity
|
Running native tests xplat
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2590/comments
| 26 |
2017-02-23T19:24:32Z
|
2019-06-07T18:49:43Z
|
https://github.com/chakra-core/ChakraCore/issues/2590
| 209,858,551 | 2,590 |
[
"chakra-core",
"ChakraCore"
] |
I'm working on a dotnetcore project which adds scripting feature to dotnet applications.
while working on support expose a `Task<T>` dotnet function to a JavaScript which returns a Promise instance.
I've managed to map an `Action<Action<T>,Action<String>>` as the Promise constructor, call to the first argument `Action<T>` will be translated to a JSCallFunction call to the javascript "resolve" anonymouse function.
The problem is JSCallFunction is a prototype call, it requires thisArg be the first parameter. I tried many objects, all triggered dotnetcore runtime fatal exception.
what I've tried:
1. the external javascript object act as my a dotnet class
2. the GlobalObject
3. the Promise instance created from Promise construct call
4. Undefined
5. Null
6. Promise function(I know it's not an object, just try my luck)
I've checked the JavaScriptvalue mapped to `Action<T>` is not disposed, I can call `AddRef()` on that with success result.
|
Calling to [resolve] function inside the Promise constructor function will crash if you call from JSRT API
|
https://api.github.com/repos/chakra-core/ChakraCore/issues/2585/comments
| 6 |
2017-02-23T17:22:19Z
|
2017-02-24T07:25:39Z
|
https://github.com/chakra-core/ChakraCore/issues/2585
| 209,828,042 | 2,585 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.