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"
] | It looks like the `args.Info.Count` would be at least `1` for `this`. If that's the case, we can safely remove those checks from our codebase.
| Remove "args.Info.Count == 0" checks | https://api.github.com/repos/chakra-core/ChakraCore/issues/387/comments | 0 | 2016-02-24T21:43:46Z | 2018-02-15T00:42:44Z | https://github.com/chakra-core/ChakraCore/issues/387 | 136,195,089 | 387 |
[
"chakra-core",
"ChakraCore"
] | Sometimes loading a big file through Microsoft edge or internet explorer causes the browser to crash or freeze and load the web page slowely.
For an example please see https://gerrit.wikimedia.org/r/#/c/272954/2/zuul/layout.yaml
Also this problem happened in webkit which I hope has been fixed with https://bugs.webkit.org/show_bug.cgi?id=154068
In google chrome the web page is loaded almost instantly without freeze.
It happends on GitHub here to, viewing large diffs causes slowness or crashes.
Works in chrome.
| Sometimes loading big diffs causes browser to crash or freeze | https://api.github.com/repos/chakra-core/ChakraCore/issues/383/comments | 2 | 2016-02-24T13:55:41Z | 2016-03-08T04:26:12Z | https://github.com/chakra-core/ChakraCore/issues/383 | 136,068,091 | 383 |
[
"chakra-core",
"ChakraCore"
] | I'm not sure if this is the correct place to file this issue, so please feel free to redirect me.
I'm using Microsoft Edge 25.10586.0.0, EdgeHTML 13.10586.
This is the code I'm running in the console:
``` js
function Person(name) {
console.log(new.target);
}
var person = new Person();
```
The console then reports a thrown error and outputs:
```
'<_lexicalNewTargetSymbol>' is undefined
```
I expected that it would output the function. It seems like this has been somewhat implemented due to the content of that error message, but perhaps not completely?
| Error thrown access new.target | https://api.github.com/repos/chakra-core/ChakraCore/issues/378/comments | 3 | 2016-02-23T18:23:16Z | 2016-03-10T23:07:08Z | https://github.com/chakra-core/ChakraCore/issues/378 | 135,820,913 | 378 |
[
"chakra-core",
"ChakraCore"
] | There was previously an inconsistency between [[Get]]/[[Set]] and [[HasProperty]] as noted in https://github.com/tc39/ecma262/issues/347. However, we did not comply with the old semantics either (our [[HasProperty]] seemed to be guarded on the receiver as well). The new semantics remove all the receiver checks.
``` js
var o = {__proto__: new Int32Array(100)};
Object.prototype[1.3] = 100;
print(o[1.3]);
print(Reflect.has(o, '1.3'));
```
Expected: undefined/false (same as v8)
Actual: 100/true (same as sm)
| Incorrect results for [[Get]] and [[HasProperty]] with Typed Array in prototype | https://api.github.com/repos/chakra-core/ChakraCore/issues/374/comments | 13 | 2016-02-22T22:49:35Z | 2017-03-16T20:20:26Z | https://github.com/chakra-core/ChakraCore/issues/374 | 135,570,069 | 374 |
[
"chakra-core",
"ChakraCore"
] | [Test262 PR](https://github.com/tc39/test262/pull/509)
| TypedArray constructors should fail when the object argument contains an element not convertible to Number | https://api.github.com/repos/chakra-core/ChakraCore/issues/361/comments | 6 | 2016-02-20T00:34:36Z | 2017-07-07T00:34:47Z | https://github.com/chakra-core/ChakraCore/issues/361 | 135,011,043 | 361 |
[
"chakra-core",
"ChakraCore"
] | GitHub now supports issue and PR templates: https://github.com/blog/2111-issue-and-pull-request-templates
Do we want to set some of these up? What would we want to put in them?
@abchatra
| Add Issue and PR GitHub Templates | https://api.github.com/repos/chakra-core/ChakraCore/issues/360/comments | 3 | 2016-02-19T23:45:40Z | 2016-07-19T00:58:15Z | https://github.com/chakra-core/ChakraCore/issues/360 | 135,004,241 | 360 |
[
"chakra-core",
"ChakraCore"
] | I am not sure where is the best place to surface this. Perhaps multiple places -
1. Here in the wiki.
2. In the Edge change log.
3. In the Windows Insider announcement blog (https://blogs.windows.com/windowsexperience/2016/02/19/announcing-windows-10-mobile-insider-preview-build-14267/ for example).
Basically a table of
```
Windows Insider Build Number | Platform | ChakaraCore Base Revision
14267 | Desktop | https://github.com/Microsoft/ChakraCore/commit/c70cd6cf9daf609ca4139ef148cd1743081d22ea
14267 | Mobile | https://github.com/Microsoft/ChakraCore/commit/6e90b4adb9bbc042289b4e45d8dd7145aebcbb0e
```
| Reveal Windows Insider and ChakraCore (base) revision mapping | https://api.github.com/repos/chakra-core/ChakraCore/issues/359/comments | 9 | 2016-02-19T23:09:03Z | 2018-02-27T21:51:30Z | https://github.com/chakra-core/ChakraCore/issues/359 | 134,997,819 | 359 |
[
"chakra-core",
"ChakraCore"
] | Second bullet point of [block static semantics](https://tc39.github.io/ecma262/#sec-block-static-semantics-early-errors) and similarly for function body static semantics.
E.g.
``` javascript
let x;
{
var x; // error (already works)
let y;
var y; // should be an error (doesn't work)
{
var y; // should also be an error (doesn't work)
}
}
```
This applies for var declarations hoisting past all lexical declarations, i.e. `let`, `const`, `class`, `function` (and generators and async functions).
| Hoisting a var declaration past a lexical declaration of the same name should be a SyntaxError | https://api.github.com/repos/chakra-core/ChakraCore/issues/357/comments | 4 | 2016-02-19T20:15:32Z | 2019-06-07T18:35:07Z | https://github.com/chakra-core/ChakraCore/issues/357 | 134,962,412 | 357 |
[
"chakra-core",
"ChakraCore"
] | Our implementation of const semantics no longer match the final semantics settled upon in the ES6 publication. Const assignment used to be an early error but now the spec deems it a late runtime error.
const declarations are created in an environment record via [CreateImmutableBinding](https://tc39.github.io/ecma262/#sec-declarative-environment-records-createimmutablebinding-n-s)(name, true). The second argument means that the binding is made "strict" which is important below.
Assignments to variables are evaluated via [PutValue](https://tc39.github.io/ecma262/#sec-putvalue). E.g. step 1.f for simple assignment in https://tc39.github.io/ecma262/#sec-assignment-operators-runtime-semantics-evaluation
In the case of a variable assignment, PutValue calls into [SetMutableBinding](https://tc39.github.io/ecma262/#sec-declarative-environment-records-setmutablebinding-n-v-s) on the corresponding environment record. SetMutableBinding throws if the S parameter is true in step 6. For const variables this parameter will be true (see CreateImmutableBinding above).
E.g.
``` javascript
print('hello'); // 'hello' should be printed
const x = foo(); // foo() should be called, then TypeError thrown
// Instead we throw a SyntaxError during parse.
```
| Should be a runtime TypeError to assign to a const variable, not an early SyntaxError | https://api.github.com/repos/chakra-core/ChakraCore/issues/355/comments | 3 | 2016-02-19T19:44:35Z | 2016-03-18T06:01:11Z | https://github.com/chakra-core/ChakraCore/issues/355 | 134,955,498 | 355 |
[
"chakra-core",
"ChakraCore"
] | ChakraCore currently allows lexical declarations (let, const, class, function*) to appear after a label. Labels can only prepend a Statement, not a Declaration, according to the ES spec.
See grammar at https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
FunctionDeclaration gets an exception and is allowed, presumably for back-compat. GeneratorDeclaration does not get the exception, however, and so it not allow. See [LabelledItem](https://tc39.github.io/ecma262/#prod-LabelledItem)
Async functions presumably will also be disallowed by way of being a HoistableDeclaration and not excepted by LabelledItem.
E.g. each of these lines should be a syntax error but are not currently:
``` javascript
a: let x;
b: const y = 0;
c: class z { }
d: function* w() { }
e: async function u() { } // pending finalization of async function spec
```
| Lexical Declarations cannot appear after a label | https://api.github.com/repos/chakra-core/ChakraCore/issues/352/comments | 5 | 2016-02-19T19:23:21Z | 2018-07-24T00:37:41Z | https://github.com/chakra-core/ChakraCore/issues/352 | 134,951,388 | 352 |
[
"chakra-core",
"ChakraCore"
] | [Test262 PR](https://github.com/tc39/test262/pull/505)
| Intl built-in functions have wrong names | https://api.github.com/repos/chakra-core/ChakraCore/issues/351/comments | 2 | 2016-02-19T19:05:24Z | 2016-03-30T22:43:47Z | https://github.com/chakra-core/ChakraCore/issues/351 | 134,947,872 | 351 |
[
"chakra-core",
"ChakraCore"
] | CustomHeap.cpp is currently not built on Linux (for no particular reason other than it's not needed until we port the JIT/dynamically allocated code pages to Linux). This issue tracks re-enabling this in the CMakeList for lib\Common\Memory.
| [linux] Get CustomHeap compiling on Linux | https://api.github.com/repos/chakra-core/ChakraCore/issues/347/comments | 1 | 2016-02-18T23:57:52Z | 2016-11-10T07:42:55Z | https://github.com/chakra-core/ChakraCore/issues/347 | 134,733,468 | 347 |
[
"chakra-core",
"ChakraCore"
] | Output::DirectPrint relies on Win32 Console APIs to change the color to be used while printing to the Console. We should use a cross-platform approach here- perhaps ANSI control characters? @dilijev any ideas here?
| [linux] Add coloring to the Output class | https://api.github.com/repos/chakra-core/ChakraCore/issues/346/comments | 9 | 2016-02-18T23:55:47Z | 2018-06-27T23:20:53Z | https://github.com/chakra-core/ChakraCore/issues/346 | 134,733,195 | 346 |
[
"chakra-core",
"ChakraCore"
] | These two files rely on Win32 APIs for dealing with daylights-savings. We'll need to replace/augment this with a cross-platform solution.
| [linux] Build DateUtilities.cpp/NumberUtilities_strtod.cpp | https://api.github.com/repos/chakra-core/ChakraCore/issues/345/comments | 1 | 2016-02-18T23:53:34Z | 2016-03-03T03:36:56Z | https://github.com/chakra-core/ChakraCore/issues/345 | 134,732,927 | 345 |
[
"chakra-core",
"ChakraCore"
] | A stub API- GetCurrentThreadStackBounds- is defined in CommonPal currently. We need to implement it to replace instances in the code where we rely on the Win32 specific-NtTeb to get the current thread's stack base and limit. One possible implementation for this API would be to use the NtTeb approach on Windows and pthread_attr_getstack on platforms with pthread support. It's unclear if we can do this without using pthread_attr_get_np though.
| [linux] Implement GetCurrentThreadStackBounds | https://api.github.com/repos/chakra-core/ChakraCore/issues/344/comments | 2 | 2016-02-18T23:52:13Z | 2016-11-10T07:41:53Z | https://github.com/chakra-core/ChakraCore/issues/344 | 134,732,651 | 344 |
[
"chakra-core",
"ChakraCore"
] | Static valid pointer maps for the Recycler are disabled on Linux builds. This is because the maps (under lib\Common\Memory\ValidPointerMap) generated don't currently compile with clang. The generation code (GenerateValidPointersMap) in HeapInfo.cpp needs to be updated to generate cross-platform VPMs, after which we can re-enable the feature.
| [linux] Re-enable static valid pointer maps | https://api.github.com/repos/chakra-core/ChakraCore/issues/343/comments | 0 | 2016-02-18T23:47:47Z | 2018-05-07T23:02:18Z | https://github.com/chakra-core/ChakraCore/issues/343 | 134,731,787 | 343 |
[
"chakra-core",
"ChakraCore"
] | The STACK_BACK_TRACE Macro is disabled on Linux currently since the StackBackTrace class depends on the CaptureStackBackTrace and Symbol resolution Win32 APIs. We should re-enable it since it helps in debugging memory issues and is also used by the Exception object in the runtime.
| [linux] Enable STACK_BACK_TRACE on linux | https://api.github.com/repos/chakra-core/ChakraCore/issues/342/comments | 2 | 2016-02-18T23:44:31Z | 2018-05-16T22:34:12Z | https://github.com/chakra-core/ChakraCore/issues/342 | 134,731,281 | 342 |
[
"chakra-core",
"ChakraCore"
] | Recent feedback I've heard about Chakra, which applies to ChakraCore as well. I think tracking the issue here would be beneficial to confused users and serve as a good link for the future.
> In the three most recent projects I’ve seen or used Chakra, everyone is re-implementing timers and promise continuation queues etc. when hosting. It would be great if there were default implementations that could be plugged in.
The current state of the world is,
- Promise continuation - To use promises in scripts, JSRT users need to supply a [JsPromiseContinuationCallback](https://github.com/Microsoft/ChakraCore/wiki/JsPromiseContinuationCallback) specifying the task-queuing mechanism because it is very host-specific. If all you want is a working implementation, we have code snippet in [documentation](https://github.com/Microsoft/ChakraCore/wiki/JavaScript-Runtime-%28JSRT%29-Overview#promises) or [sample](https://github.com/Microsoft/Chakra-Samples/blob/master/Chakra Samples/JSRT Universal Windows Apps Hosting Samples/C%2B%2B/JsRT_UWP_Sample/ChakraHost.cpp#L8) that you can copy from.
- Timers - this again is a host-specific thing and we do not provide default implementation. There might be some copy-able code in ch.exe.
| [JSRT] Default implementation for promise continuation & timers | https://api.github.com/repos/chakra-core/ChakraCore/issues/341/comments | 7 | 2016-02-18T23:11:08Z | 2018-10-26T09:49:46Z | https://github.com/chakra-core/ChakraCore/issues/341 | 134,725,932 | 341 |
[
"chakra-core",
"ChakraCore"
] | ``` javascript
function* gf() {
var a = (yield) => { }; // spec says error, ChakraCore gives no error
var b = (x = yield) => { }; // spec says error, ChakraCore produces no error
}
```
This is an error by way of ArrowFunction passing the Yield parameter on to its StrictFormalParameters. This is different from FunctionExpression which drops the Yield parameter entirely from its production.
https://tc39.github.io/ecma262/#sec-arrow-function-definitions
https://tc39.github.io/ecma262/#prod-FunctionExpression
| yield should be reserved word in arrow functions within StrictFormalParameters | https://api.github.com/repos/chakra-core/ChakraCore/issues/333/comments | 1 | 2016-02-18T03:46:28Z | 2016-11-03T23:24:23Z | https://github.com/chakra-core/ChakraCore/issues/333 | 134,473,971 | 333 |
[
"chakra-core",
"ChakraCore"
] | Currently ChakraCore disables ETW because of reliance on private manifests. I think we should look into making new instrumentation manifests for ChakraCore to enable ETW support.
| Add ETW support | https://api.github.com/repos/chakra-core/ChakraCore/issues/328/comments | 3 | 2016-02-17T23:34:38Z | 2018-07-18T11:04:11Z | https://github.com/chakra-core/ChakraCore/issues/328 | 134,434,239 | 328 |
[
"chakra-core",
"ChakraCore"
] | We currently throw a syntax error for the following case:
``` js
let get = 1;
let obj = { get };
```
| `{get}` should be a valid object literal | https://api.github.com/repos/chakra-core/ChakraCore/issues/320/comments | 3 | 2016-02-17T00:00:16Z | 2016-02-17T22:40:51Z | https://github.com/chakra-core/ChakraCore/issues/320 | 134,132,167 | 320 |
[
"chakra-core",
"ChakraCore"
] | There are a handful of tests which by their nature are timezone-sensitive (testing Date APIs). Because the execution of some Javascript Date APIs is dependent on the system time zone, the tests only work when run in the time zone in which the baselines were created (in our case, Pacific Time [UTC-8]).
The Jenkins machines are configured with UTC time and so we noticed that these tests would fail in any other timezone. To work around the problem for now, we disabled these tests in Jenkins.
It would be nice to add a way to enable these tests.
My thoughts:
- Some of these tests may not need to depend on the time zone. If possible, modify the tests to make them more general (as long as we keep exercising the same code paths).
- Add a flag to the test runner (`rl.exe`) and/or `ch.exe` which provides the ability to spoof the system timezone for tests, so that we can test the right code paths within ChakraCore which do depend on the system's reported time zone.
To locate the affected tests which were disabled in Jenkins, you can run:
`git grep -n -C 3 "timezone-sensitive"`
/cc @digitalinfinity @tcare @ianwjhalliday @kunalspathak FYI
Converted from [VSO 5239718](https://microsoft.visualstudio.com/web/wi.aspx?pcguid=cb55739e-4afe-46a3-970f-1b49d8ee7564&id=5239718)
| Fix timezone-sensitive tests (disabled in Jenkins) | https://api.github.com/repos/chakra-core/ChakraCore/issues/319/comments | 14 | 2016-02-16T23:56:54Z | 2021-02-25T02:40:47Z | https://github.com/chakra-core/ChakraCore/issues/319 | 134,131,605 | 319 |
[
"chakra-core",
"ChakraCore"
] | Building with just [Microsoft Visual C++ Build Tools 2015 Technical Preview](https://blogs.msdn.microsoft.com/vcblog/2015/11/02/announcing-visual-c-build-tools-2015-standalone-c-tools-for-build-environments/).
On Win 10 Pro with only the Build tools (both 8 and 10 SDKs installed via tool) using
- Visual C++ x64 Native Build Tools Command Prompt
- set VS140COMNTOOLS=C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Tools\
- cmd> vcbuild chakracore nosign x64
will fail to build with failures due to being unable to find cor.h.
For build VMs that dont need all of VS.
closed same issue under [nodejs/node-chakracore issue #24](https://github.com/nodejs/node-chakracore/issues/24)
Thanks @kunalspathak: "this is known problem and related to windows 8.1 SDK header dependencies of chakracore. Unfortunately you will need to install VS 2013 or VS 2015 for now to address it until we work on removing the dependency. Feel free to open an issue on Microsoft/Chakracore."
First error:
`c:\dev\cygwin\home\am\node-chakracore\deps\chakrashim\core\lib\runtime\Base\DelayLoadLibrary.h(14): fatal error C1083: Cannot open include file: 'cor.h': No such file or directory [C:\dev\cygwin\home\am\node-chakracore\deps\chakrashim\core\lib\jsrt\Chakra.Jsrt.vcxproj] [C:\dev\cygwin\home\am\node-chakracore\deps\chakrashim\chakracore.vcxproj]`
```
C:\dev\cygwin\home\am\node-chakracore>vcbuild chakracore nosign x64
Looking for Visual Studio 2015
Found Visual Studio 2015
configure --engine=chakracore --dest-cpu=x64 --tag=
ctrpp not found in WinSDK path--using pre-gen files from tools/msvs/genfiles.
creating icu_config.gypi
{ 'target_defaults': { 'cflags': [],
'default_configuration': 'Release',
'defines': [],
'include_dirs': [],
'libraries': []},
'variables': { 'asan': 0,
'host_arch': 'x64',
'icu_small': 'false',
'node_byteorder': 'little',
'node_enable_v8_vtunejit': 'false',
'node_engine': 'chakracore',
'node_install_npm': 'true',
'node_prefix': '/usr/local',
'node_release_urlbase': '',
'node_shared_http_parser': 'false',
'node_shared_libuv': 'false',
'node_shared_openssl': 'false',
'node_shared_zlib': 'false',
'node_tag': '',
'node_use_dtrace': 'false',
'node_use_etw': 'true',
'node_use_lttng': 'false',
'node_use_openssl': 'true',
'node_use_perfctr': 'true',
'openssl_fips': '',
'openssl_no_asm': 0,
'python': 'C:\\dev\\python27\\python.exe',
'target_arch': 'x64',
'v8_enable_gdbjit': 0,
'v8_enable_i18n_support': 0,
'v8_no_strict_aliasing': 1,
'v8_optimized_debug': 0,
'v8_random_seed': 0,
'v8_use_snapshot': 'true',
'want_separate_host_toolset': 0}}
```
| building with Microsoft Visual C++ Build Tools 2015 Technical Preview | https://api.github.com/repos/chakra-core/ChakraCore/issues/314/comments | 0 | 2016-02-15T07:30:51Z | 2018-03-01T00:55:28Z | https://github.com/chakra-core/ChakraCore/issues/314 | 133,643,662 | 314 |
[
"chakra-core",
"ChakraCore"
] | Today inside function that reads `arguments` object, we need to create heap object that copies arguments on the stack into this heap object. The reason being the function can return the `arguments` and caller should have access to those arguments. However for functions which don't return `arguments`, ChakraCore does optimization where it doesn't create heap object (and thus skip copying of stack arguments into this heap object).
In below example, `foo` doesn't return `arguments` object and hence we optimize `... = arguments`cases by loading the values from stack instead of creating heap objects for them and then using it.
``` js
function foo()
{
// ...
x = arguments[i]
// ...
}
```
But if function have formal parameters, we don't do this optimization. While investigating Microsoft/node#6, I noticed that there were lot of hot javascript functions that takes formal parameters and has reads from `arguments` objects.
E.g. Here are some functions in node code :
- https://github.com/nodejs/node-chakracore/blob/chakracore-master/lib/timers.js#L421
- https://github.com/nodejs/node-chakracore/blob/chakracore-master/src/node.js#L506
- https://github.com/nodejs/node-chakracore/blob/chakracore-master/lib/net.js#L615
- https://github.com/nodejs/node-chakracore/blob/chakracore-master/lib/events.js#L118
For every call we create heap objects for arguments and hence spend lot of time in this instead of executing the functions. In my experiment, I replaced `arguments` reads with formal parameters and noticed the node+chakracore performance improves by 1.5X times.
We should optimize such scenarios to get better performance improvement.
| Optimize LdHeapArguments in presence of formal parameters | https://api.github.com/repos/chakra-core/ChakraCore/issues/313/comments | 1 | 2016-02-13T10:10:01Z | 2017-06-01T07:32:27Z | https://github.com/chakra-core/ChakraCore/issues/313 | 133,419,411 | 313 |
[
"chakra-core",
"ChakraCore"
] | I cloned chakracore on a machine that has VS2013 12.0.21005.1 REL. The build fails because VS2013 doesn’t support `constexpr` that was recently added by @leirocks in 5619992ce85358277b744bd8317ba8546d83d654. This is also mentioned in [compatibility table](https://msdn.microsoft.com/library/hh567368.aspx#corelanguagetable) and mentioned [here](http://herbsutter.com/2013/09/09/visual-studio-2013-rc-is-now-available/#comment-13540).
This is supported starting [November 2013 CTP](https://www.microsoft.com/en-us/download/details.aspx?id=41151) update. Our wiki page
Since wiki page that talks about [building chakracore](https://github.com/Microsoft/ChakraCore/wiki/Building-ChakraCore) simply list VS2013 as prerequisite but doesn't mention specific version.
I am opening this issue to discuss the guidelines we should have for contributors regarding adding new C++ language features while still maintaining the prerequisite of Visual Studio.
- If we want contributors to use latest and greatest C++ language features, we should update our wiki page to point the right Visual studio version pre-requisite containing those language features.
- If want to stick to language features available in RC versions of Visual Studio 2013/2015, then we should point it out in code reviews.
Whatever we decide, we should have some pre-checks build task that verify chakracore builds correctly with VS 2013 and VS 2015 that is mentioned on wiki page. This will help to catch these issues instantly.
| Chakracore build break on VS2013 RC | https://api.github.com/repos/chakra-core/ChakraCore/issues/309/comments | 13 | 2016-02-13T00:54:48Z | 2016-08-26T01:23:54Z | https://github.com/chakra-core/ChakraCore/issues/309 | 133,380,166 | 309 |
[
"chakra-core",
"ChakraCore"
] | It would be great if there was some documentation on how chakra implements the JS datastructures such as arrays and objects and what goes on in the JIT world.
| Chakra JS data structure documentation | https://api.github.com/repos/chakra-core/ChakraCore/issues/306/comments | 8 | 2016-02-12T05:01:43Z | 2018-02-15T18:20:12Z | https://github.com/chakra-core/ChakraCore/issues/306 | 133,158,415 | 306 |
[
"chakra-core",
"ChakraCore"
] | Currently default parameter value initializers are evaluated on the first call to `next()` on the resulting generator object from a call to a generator function. The ES spec says they should be evaluated on the call to the generator function itself, before it returns the generator object.
E.g.
``` javascript
let x = 0;
function* gf(a = x = 1) { }
let g = gf();
print(x); // should print 1, not 0
```
One simple solution might be to put a yield between the default parameter initializers and the body in the bytecode and then in the generator function call stub, call next() once, then return the generator object.
| Generator function default parameter value initializers should be evaluated when the generator function is called not at first next() call | https://api.github.com/repos/chakra-core/ChakraCore/issues/300/comments | 5 | 2016-02-11T19:03:07Z | 2017-05-17T22:24:14Z | https://github.com/chakra-core/ChakraCore/issues/300 | 133,059,103 | 300 |
[
"chakra-core",
"ChakraCore"
] | From test262
test262\test\language\statements\class\name_binding\const.js
``` javascript
// Copyright (C) 2014 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
es6id: 14.5
description: >
class name binding const
---*/
assert.throws(TypeError, function() {
class C { constructor() { C = 42; } }; new C();
});
assert.throws(TypeError, function() {
new (class C { constructor() { C = 42; } })
});
assert.throws(TypeError, function() {
class C { m() { C = 42; } }; new C().m()
});
assert.throws(TypeError, function() {
new (class C { m() { C = 42; } }).m()
});
assert.throws(TypeError, function() {
class C { get x() { C = 42; } }; new C().x
});
assert.throws(TypeError, function() {
(new (class C { get x() { C = 42; } })).x
});
assert.throws(TypeError, function() {
class C { set x(_) { C = 42; } }; new C().x = 15;
});
assert.throws(TypeError, function() {
(new (class C { set x(_) { C = 42; } })).x = 15;
});
// expected result
// type errors thrown and caught
// actual result
// early syntax error
```
| Assignment to class name inside class body should be type error | https://api.github.com/repos/chakra-core/ChakraCore/issues/299/comments | 2 | 2016-02-11T18:33:23Z | 2016-03-18T06:01:31Z | https://github.com/chakra-core/ChakraCore/issues/299 | 133,052,465 | 299 |
[
"chakra-core",
"ChakraCore"
] | Currently -includeSlow is only specified on the [Builds with Slow Tests](https://github.com/Microsoft/ChakraCore/wiki/Build-Status#builds-with-slow-tests) configuration.
Since the Legacy builds also run once per day it makes sense to add -includeSlow to increase coverage.
| Enable -includeSlow on Legacy daily builds. | https://api.github.com/repos/chakra-core/ChakraCore/issues/283/comments | 1 | 2016-02-09T03:23:14Z | 2016-03-21T19:07:41Z | https://github.com/chakra-core/ChakraCore/issues/283 | 132,321,743 | 283 |
[
"chakra-core",
"ChakraCore"
] | The grammar for setter and getter methods is such that they only allow exactly one and zero formal parameters respectively. We appear to get this correct for object literals, and correct for getters in classes, but we allow any number of parameters for class setters.
``` javascript
class C {
set foo(a, b, c) { } // should be a syntax error
set bar() { } // should also be a syntax error
}
```
https://tc39.github.io/ecma262/#sec-method-definitions
| Class setters do not fail to parse when they have zero or more than one formal parameters | https://api.github.com/repos/chakra-core/ChakraCore/issues/280/comments | 1 | 2016-02-08T23:26:53Z | 2016-02-10T21:41:40Z | https://github.com/chakra-core/ChakraCore/issues/280 | 132,286,295 | 280 |
[
"chakra-core",
"ChakraCore"
] | When creating projects that target PaaS offerings in Azure such as Service Fabric or Classic Worker Roles, it is more desirable to have a version of ChakraCore that can be statically linked.
In addition it would be nice if the static library also statically linked its dependencies such as the MSVC runtime. This prevents users from having to create VM Extensions that deploy these dependencies.
| Add project that produces a static library version of ChakraCore | https://api.github.com/repos/chakra-core/ChakraCore/issues/279/comments | 5 | 2016-02-08T21:14:30Z | 2018-05-07T23:02:24Z | https://github.com/chakra-core/ChakraCore/issues/279 | 132,258,330 | 279 |
[
"chakra-core",
"ChakraCore"
] | We dont kill type specialized values across calls for perf reasons. This can be a problem when we lossy int type specialize an object. If a call following the conversion overrides, for example, valueOf on the object and the object is used as an int after the call (for example, in a shift), we will use the already available int version and end up not executing valueOf.
| Bug with lossy int type specialization | https://api.github.com/repos/chakra-core/ChakraCore/issues/277/comments | 0 | 2016-02-06T00:06:01Z | 2016-02-08T18:56:36Z | https://github.com/chakra-core/ChakraCore/issues/277 | 131,794,281 | 277 |
[
"chakra-core",
"ChakraCore"
] | At the January TC39 meeting and subsequent conversations we got consensus on removal of the [[Enumerate]] MOP operation and the associated Reflect.enumerate and proxy trap `enumerate`. A PR implementing this consensus is here: https://github.com/tc39/ecma262/pull/367.
| Remove [[Enumerate]] and associated reflective capabilities | https://api.github.com/repos/chakra-core/ChakraCore/issues/274/comments | 3 | 2016-02-05T22:58:41Z | 2016-08-26T17:43:23Z | https://github.com/chakra-core/ChakraCore/issues/274 | 131,782,966 | 274 |
[
"chakra-core",
"ChakraCore"
] | New to ChakraCore so have been playing with the ChakraCoreHost sample to get a feel for how things work. This shows how to use DefineHostCallback to create a callback to which the JavaScript provides some data, but not the reverse. For example, how do you return a string or struct from the callback to JavaScript?
Thanks.
| How do you return a string or struct from a callback to JavaScript? | https://api.github.com/repos/chakra-core/ChakraCore/issues/272/comments | 3 | 2016-02-05T15:02:18Z | 2016-02-08T18:27:08Z | https://github.com/chakra-core/ChakraCore/issues/272 | 131,665,639 | 272 |
[
"chakra-core",
"ChakraCore"
] | ``` js
var handler = {
setPrototypeOf: function (target, v) {
print("setPrototypeOf trap");
return false;
}
}
var p = new Proxy({}, handler);
Object.setPrototypeOf(p, { x: 1})
```
Expected: TypeError from Object.setPrototypeOf that doesn't mention invariant check
Actual: TypeError: Invariant check failed for setPrototypeOf proxy trap
| Proxy setPrototypeOf returning false throws wrong error | https://api.github.com/repos/chakra-core/ChakraCore/issues/271/comments | 0 | 2016-02-04T23:38:45Z | 2016-02-19T23:20:29Z | https://github.com/chakra-core/ChakraCore/issues/271 | 131,507,131 | 271 |
[
"chakra-core",
"ChakraCore"
] | #252 (https://github.com/Microsoft/ChakraCore/commit/5e560731bd5cc383e07710122550a6dcbcea4ad2) temporarily made SmartFPUControl no-op on non-Windows systems. With fix of #260, we may need to implement it.
| linux: Implement SmartFPUControl for cross-platform | https://api.github.com/repos/chakra-core/ChakraCore/issues/270/comments | 1 | 2016-02-04T23:11:08Z | 2018-03-22T00:08:45Z | https://github.com/chakra-core/ChakraCore/issues/270 | 131,502,362 | 270 |
[
"chakra-core",
"ChakraCore"
] | Right now, `WScript.LoadScriptFile` will search relative to the current working directory.
After the discussion in #244, I believe this was an oversight and this makes running test files without `rl` more difficult than it should be.
Unless someone as a valid use case to use current working directory, we should change it to use the current script's location.
| `WScript.LoadScriptFile` search relative to the script location | https://api.github.com/repos/chakra-core/ChakraCore/issues/269/comments | 1 | 2016-02-04T19:08:15Z | 2018-02-23T19:01:56Z | https://github.com/chakra-core/ChakraCore/issues/269 | 131,445,803 | 269 |
[
"chakra-core",
"ChakraCore"
] | I don't see any instance where we assign this bailout to an instruction. All the instances in the current codebase deal with checking for this bailout. Maybe it was needed at some point but not anymore? @LouisLaf @pleath @curtisman
| Remove BailOutExpectingObject | https://api.github.com/repos/chakra-core/ChakraCore/issues/266/comments | 0 | 2016-02-04T02:53:02Z | 2016-03-21T18:06:01Z | https://github.com/chakra-core/ChakraCore/issues/266 | 131,224,003 | 266 |
[
"chakra-core",
"ChakraCore"
] | When `yield*` iterates over an iterable, it is supposed to pass the iterator result object on to the caller of the generator as it is, when its done property is falsy. Looks like we are currently unwrapping the iterator result from the iterable, taking its value, and rewrapping it in a new iterator result object, that happens to have a `done: false` property added to it.
This was discovered via test262, we fail [`test/language/expressions/yield/star-iterable.js`](https://github.com/tc39/test262/blob/master/test/language/expressions/yield/star-iterable.js)
The spec states this at step 5.a.iv of _YieldExpression_: **yield *** _AssignmentExpression_ Runtime Semantics here https://tc39.github.io/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation
Issue ported from VSO bug [5116152](https://microsoft.visualstudio.com/DefaultCollection/OS/_workitems?_a=edit&id=5116152)
| Generator function yield* incorrectly unwraps and rewraps iterator results instead of passing them through | https://api.github.com/repos/chakra-core/ChakraCore/issues/265/comments | 6 | 2016-02-04T02:23:38Z | 2016-03-23T23:50:52Z | https://github.com/chakra-core/ChakraCore/issues/265 | 131,218,820 | 265 |
[
"chakra-core",
"ChakraCore"
] | _Originally this issue mentioned only the syntax error for `for (let let ...` but the issue actually applies to all `let` and `const` declarations containing a variable named `let`. See the general static semantics rule here: https://tc39.github.io/ecma262/#sec-let-and-const-declarations-static-semantics-early-errors_
---
``` javascript
for (let let = 0; false; ) { } // should be early syntax error on identifier named let
for (let let in { }) { } // ditto
for (let let of { }) { } // ditto
// and likewise when destructuring patterns are used
```
I think this was at one time decidedly not going to be an error because we thought about this case and intentionally implemented it so that it would parse.
In any case it no longer matches the spec. Spec says it should be an error.
We need to make sure we disallow the name 'let' in an arbitrary destructuring too.
https://tc39.github.io/ecma262/#sec-let-and-const-declarations-static-semantics-early-errors
https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements-static-semantics-early-errors
Ported issue from internal VSO bug [5055638](https://microsoft.visualstudio.com/DefaultCollection/OS/_workitems?_a=edit&id=5055638)
| ES6 `let let` and `const let` declarations are supposed to be a syntax error | https://api.github.com/repos/chakra-core/ChakraCore/issues/263/comments | 2 | 2016-02-04T02:05:39Z | 2016-03-11T00:48:31Z | https://github.com/chakra-core/ChakraCore/issues/263 | 131,216,729 | 263 |
[
"chakra-core",
"ChakraCore"
] | You should not be able to change its prototype with `Object.setPrototypeOf`, `__proto__`, or any other means. See also: https://github.com/tc39/ecma262/pull/308.
| Object.prototype should be an immutable prototype exotic object | https://api.github.com/repos/chakra-core/ChakraCore/issues/261/comments | 11 | 2016-02-04T01:02:38Z | 2016-04-29T00:06:56Z | https://github.com/chakra-core/ChakraCore/issues/261 | 131,206,351 | 261 |
[
"chakra-core",
"ChakraCore"
] | According to @Yongqu, our script execution needs certain FPU states, so we should save/set/restore FPU states for script execution. `SmartFPUControl` class is intended for that task. However, ChakraCore JSRT calls apparently do not conform. We don't have `SmartFPUControl` usage at all. We should review/refactor/add to any code path that could lead to script execution.
| Missing FPU state save/restore | https://api.github.com/repos/chakra-core/ChakraCore/issues/260/comments | 4 | 2016-02-03T23:23:05Z | 2019-06-07T19:01:23Z | https://github.com/chakra-core/ChakraCore/issues/260 | 131,187,482 | 260 |
[
"chakra-core",
"ChakraCore"
] | Currently, Chakra parses `/[\s-a-c]/` as:
- The character class `\s`
- The character `-`
- The range `a-c`
However, other engines parse it as:
- The range `\s-a`, which is treated as the union of class `\s`, and the characters `-` and `a`
- The character `-`
- The character `c`
As a result, Chakra matches the character `b` with this pattern whereas others don't.
Annex B of the spec has been [changed ](https://github.com/tc39/ecma262/commit/fbdfda6f2a613f3c4813d4b34e32f5c5134cf921) to the rules used by other engines, so Chakra should be updated to match the spec.
| [RegExp] /[\s-a-c]/ is parsed incorrectly | https://api.github.com/repos/chakra-core/ChakraCore/issues/258/comments | 0 | 2016-02-03T21:32:45Z | 2018-07-10T21:52:05Z | https://github.com/chakra-core/ChakraCore/issues/258 | 131,161,220 | 258 |
[
"chakra-core",
"ChakraCore"
] | lib/common/common/DateUtilities.cpp has some WinRTDate utilities that seems not used in ChakraCore. Consider move them.
| Move WinRTDate code from DateUtilities.cpp | https://api.github.com/repos/chakra-core/ChakraCore/issues/255/comments | 4 | 2016-02-03T18:50:12Z | 2018-03-22T01:00:11Z | https://github.com/chakra-core/ChakraCore/issues/255 | 131,117,843 | 255 |
[
"chakra-core",
"ChakraCore"
] | [`Object.getOwnPropertyDescriptors`](https://github.com/tc39/proposal-object-getownpropertydescriptors) is stage 3. At this time, Webkit has implemented it and v8 has an open patch.
Would be a good first PR!
| Implement Object.getOwnPropertyDescriptors | https://api.github.com/repos/chakra-core/ChakraCore/issues/254/comments | 19 | 2016-02-03T16:51:59Z | 2016-07-08T23:56:21Z | https://github.com/chakra-core/ChakraCore/issues/254 | 131,085,210 | 254 |
[
"chakra-core",
"ChakraCore"
] | Currently the properties exist, are non-configurable, and always return null.
| Built-in functions should not have properties 'caller' or 'arguments' | https://api.github.com/repos/chakra-core/ChakraCore/issues/249/comments | 2 | 2016-02-02T02:41:07Z | 2018-02-08T22:07:27Z | https://github.com/chakra-core/ChakraCore/issues/249 | 130,552,710 | 249 |
[
"chakra-core",
"ChakraCore"
] | Currently they are non-configurable.
Possible good candidate for "Your First PR"
| Function.prototype.caller/arguments should be configurable | https://api.github.com/repos/chakra-core/ChakraCore/issues/248/comments | 3 | 2016-02-02T02:40:30Z | 2018-03-05T22:37:13Z | https://github.com/chakra-core/ChakraCore/issues/248 | 130,552,553 | 248 |
[
"chakra-core",
"ChakraCore"
] | The ES spec has this static semantics early error text for all function types (declaration, expression, arrow, generator, method):
- It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of StrictFormalParameters is false.
The parser only throws a SyntaxError when there is a transition to strict mode but the spec is stating that it should always be an error regardless of strict modeness.
E.g. this should throw but doesn't:
``` javascript
function f() {
"use strict";
function g(x = 1) { "use strict"; }
}
```
| Already strict functions do not emit syntax error for non-simple parameter list mixed with "use strict" directive | https://api.github.com/repos/chakra-core/ChakraCore/issues/246/comments | 1 | 2016-02-02T01:53:25Z | 2016-02-02T19:04:19Z | https://github.com/chakra-core/ChakraCore/issues/246 | 130,544,862 | 246 |
[
"chakra-core",
"ChakraCore"
] | Right now it's really painful when trying to run a script both in node and in ch the main reason is with the way the global scope it populated.
See https://nodejs.org/api/globals.html for current list of what node exports.
I don't suggest we implement them all, maybe some simple ones like `console`, `global`, `__dirname`, `__filename`.
I would love to be able to simply write `console.log` in a script and it works everywhere.
Plus, with `__dirname` we could run script loading other script without the need to be in that current working directory.
For instance `WScript.LoadScriptFile(__dirname + "\\memset_tester.js");` would work anywhere.
Also, right now if I want to shim `print`, `WScript.Echo` and `console.log` we can't use `if(!print) print = console.log` because this throws in Node and `if(!global.print) global.print = console.log` throws in ch.exe
I already implemented some of them locally just to play around, but I wanted people's opinion before I submit it.
| Add node like api in ch.exe | https://api.github.com/repos/chakra-core/ChakraCore/issues/244/comments | 10 | 2016-02-01T22:17:26Z | 2016-02-04T19:04:39Z | https://github.com/chakra-core/ChakraCore/issues/244 | 130,502,283 | 244 |
[
"chakra-core",
"ChakraCore"
] | According to the spec, the `lastIndex` property of a RegExp instance has attributes `{[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}` and, as per [Section 6.1.7.1 Property Attributes](https://tc39.github.io/ecma262/#sec-property-attributes), it is possible to change `[[Writable]]` to `false` even when `[[Configurable]]` is `false`. However, on ChakraCore, it isn't possible.
Repro steps:
```
var re = /./;
var desc = Object.getOwnPropertyDescriptor(re, 'lastIndex');
WScript.Echo(desc.writable === true);
Object.defineProperty(re, 'lastIndex', {writable: false});
desc = Object.getOwnPropertyDescriptor(re, 'lastIndex');
WScript.Echo(desc.writable === false); // Currently prints "false"
```
| [RegExp] Can't make "lastIndex" property of a RegExp instance non-writable | https://api.github.com/repos/chakra-core/ChakraCore/issues/238/comments | 7 | 2016-02-01T17:36:42Z | 2018-09-20T00:22:07Z | https://github.com/chakra-core/ChakraCore/issues/238 | 130,429,491 | 238 |
[
"chakra-core",
"ChakraCore"
] | The assignment target should obey `const` semantics.
Test262 bug es6id: 12.14.5.4
features: [const]
``` js
const c = 1;
assert.throws(TypeError, function() {
({ a: c } = { a: 2 });
});
```
| Destructuring assignment target should obey const semantics | https://api.github.com/repos/chakra-core/ChakraCore/issues/235/comments | 2 | 2016-01-30T01:25:47Z | 2016-02-26T00:15:31Z | https://github.com/chakra-core/ChakraCore/issues/235 | 129,925,176 | 235 |
[
"chakra-core",
"ChakraCore"
] | `
for (let []; ;) { }
`
Above code should throw `Syntax error`as in declaration head the array destructuring pattern does not have initializer.
| Native for loop does not raise error when head has destructuring declaration without initializer | https://api.github.com/repos/chakra-core/ChakraCore/issues/225/comments | 2 | 2016-01-28T23:10:21Z | 2016-02-02T19:40:51Z | https://github.com/chakra-core/ChakraCore/issues/225 | 129,613,627 | 225 |
[
"chakra-core",
"ChakraCore"
] | http://www.gnu.org/software/libc/manual/html_node/Getopt-Long-Options.html
ch.exe accepts both forward slash and a single dash for all switches recognized. Reasonable given Chakra has been a Windows only project up until.
However, now that we are porting to linux and expect to later port to other POSIX platforms it feels like a good idea to consider conforming command line syntax to that of gnu gnu getopt_long syntax. *nix tools widely adhere to this syntax and it is reasonable to presume that *nix users are very comfortable with this syntax, to the point that using a tool that does not conform will be aesthetically jarring.
Functionally it may not be a problem for plugging ch.exe into scripts and other *nix tools, but it will probably frustrate many a user. Perhaps it could also impose complication on scripts/tools so that they can support the windows-esque syntax.
I believe this is not a priority but something worth considering as the linux port comes online.
| Change ch.exe to comply with gnu getopt_long argument syntax | https://api.github.com/repos/chakra-core/ChakraCore/issues/223/comments | 5 | 2016-01-28T22:58:28Z | 2016-08-25T21:04:25Z | https://github.com/chakra-core/ChakraCore/issues/223 | 129,611,456 | 223 |
[
"chakra-core",
"ChakraCore"
] | For PR #215, I was looking at codegen on test\benchmarks\Kraken\audio-oscillator.js to try to understand perf regression, and I see this is essentially the entire benchmark:
``` js
for ( var i = 0; i < this.bufferSize; i++ ) {
offset = Math.round((frameOffset + i) * step);
this.signal[i] = this.waveTable[offset % this.waveTableLength] * this.amplitude;
}
```
surprising thing is we are emitting a fixed field check for Math.round inside the loop, but I'd think it should be provable that it is loop invariant.
I spoke with @LouisLaf and it seems because this isn't value producing, PRE doesn't catch it. It is meant to be caught by invariant hoisting, but currently that doesn't catch everything. So... if anyone wants to dive in and investigate, I think this could be low hanging fruit (relatively speaking) for JIT work. It's possible that it's more complicated... but that needs investigation.
This is check I'm seeing that I think should be hoisted:
```
Line 735: offset = Math.round((frameOffset + i) * step);
Col 5: ^
StatementBoundary #4 #0048
GLOBOPT INSTR: Nop #0048
TEST s80<s94>[LikelyCanBeTaggedValue_Object].var, 1 (0x1).i8 #
JNE $L59 #
s135.i32 = MOV [s80<s94>[LikelyCanBeTaggedValue_Object].var+4].i32 #
CMP s135.i32, [0xXXXXXXXX (&GuardValue)].u32 #
JNE $L59 #
JMP $L60 #
$L59: [helper] #
$L61: [helper] #
CALL SaveAllRegistersAndBailOut.u32 #004e Bailout: #004e (BailOutFailedFixedFieldTypeCheck)
JMP $L13 #
$L60: #
```
| Not hoisting fixed field checks out of loop (at least in some cases) | https://api.github.com/repos/chakra-core/ChakraCore/issues/222/comments | 1 | 2016-01-28T21:50:17Z | 2018-03-21T23:58:51Z | https://github.com/chakra-core/ChakraCore/issues/222 | 129,592,767 | 222 |
[
"chakra-core",
"ChakraCore"
] | Last night there was a brief discussion on Gitter about community contributions to the wiki. Even though the wiki is a git repo itself, GitHub does not allow pull requests to the wiki. We either allow everyone in the open to edit freely or restrict contributor access to contributors only, so the community cannot edit at all. As a point of order, it seems that the latter is the only option that really makes sense for us.
Ideally, we would have some system by which contributors can add or edit documentation subject to review.
Other projects get around this problem by having documentation under a docs directory. Example given was Roslyn's GitHub repo in particular this issue: dotnet/roslyn#7498.
I came up with the idea of hosting a mirror of the wiki's git repo on a GitHub repo. We could call it Microsoft/ChakraCoreWiki or Microsoft/ChakraCoreDocs. This would allow us to bypass all of the Jenkins checks and other test infrastructure and have an entire repo of text-only changes. We can periodically sync the changes to that repo to the Microsoft/ChakraCore/wiki.git.
Thoughts?
| [Discussion] [Meta] How to enable community contribution to the wiki. | https://api.github.com/repos/chakra-core/ChakraCore/issues/220/comments | 18 | 2016-01-28T20:12:27Z | 2016-04-29T21:50:58Z | https://github.com/chakra-core/ChakraCore/issues/220 | 129,565,767 | 220 |
[
"chakra-core",
"ChakraCore"
] | There is a strange thing. When I call _Engine.CallGlobalFunction("Decipher", new[] { _Engine.Converter.FromString(strSignature) }) I get OutOfMemoryException after approximately 5 seconds delay on the method. "Decipher" function is rather simple. Besides it works fine if I call _Engine.Execute(new ScriptSource("Inline", $@"Decipher('{strSignature}');"));. What am I doing wrong?
Thanks,
Alex
| OutOfMemoryException calling CallGlobalFunction | https://api.github.com/repos/chakra-core/ChakraCore/issues/218/comments | 0 | 2016-01-28T18:39:45Z | 2016-05-03T00:05:15Z | https://github.com/chakra-core/ChakraCore/issues/218 | 129,539,300 | 218 |
[
"chakra-core",
"ChakraCore"
] | In #206, @obastemur has implemented unix version of _mul128 using inline assembly. Consider getting this in to optimize Int64::Mul.
> Prepared a unix/linux version of `__mul128` https://gist.github.com/obastemur/48125aacb960a5b66730
| linux: unix version of _mul128 to optimize Int64::Mul | https://api.github.com/repos/chakra-core/ChakraCore/issues/217/comments | 3 | 2016-01-28T16:58:33Z | 2016-09-02T04:36:43Z | https://github.com/chakra-core/ChakraCore/issues/217 | 129,510,723 | 217 |
[
"chakra-core",
"ChakraCore"
] | Hi,
Before I replace v8 in our server app with chakra core, I am going to test simple javascript.
When I tried hello world sample, SEHException was occured in creating an context.
When native code debugging is enabled I can see it failed to initialize COM interface.
AssertMsg(false, "Failed to initialize COM interfaces, verify correct version of globalization dll is used.");
This only happens to my work machine.
Anyone experienced this problem?
Thanks,
| Win7 without IE11: How to Fix: "Failed to initialize COM interfaces" | https://api.github.com/repos/chakra-core/ChakraCore/issues/212/comments | 9 | 2016-01-27T21:52:59Z | 2016-01-28T00:13:39Z | https://github.com/chakra-core/ChakraCore/issues/212 | 129,281,307 | 212 |
[
"chakra-core",
"ChakraCore"
] | `AutoSysInfo` has code to detect physical/logical CPU cores. The code primarily cares about number of physical cores. Linux port currently uses PAL implementation. Need to verify if it works/suffices.
| linux: detect number of physical/logical CPU cores | https://api.github.com/repos/chakra-core/ChakraCore/issues/200/comments | 4 | 2016-01-26T20:00:25Z | 2018-03-21T23:54:57Z | https://github.com/chakra-core/ChakraCore/issues/200 | 128,925,610 | 200 |
[
"chakra-core",
"ChakraCore"
] | Need to add test for `Intl` object in ChakraCore.
| Add test for Intl in Chakracore | https://api.github.com/repos/chakra-core/ChakraCore/issues/199/comments | 2 | 2016-01-26T19:56:38Z | 2017-04-06T22:17:22Z | https://github.com/chakra-core/ChakraCore/issues/199 | 128,924,550 | 199 |
[
"chakra-core",
"ChakraCore"
] | Instead of testing IsWindows8OrGreater, we should examine each usage and switch to enable/disable feature instead. That'll make code cleaner.
| linux: Switch from IsWindows8OrGreater to feature detection | https://api.github.com/repos/chakra-core/ChakraCore/issues/198/comments | 5 | 2016-01-26T19:54:29Z | 2018-02-22T22:05:33Z | https://github.com/chakra-core/ChakraCore/issues/198 | 128,923,960 | 198 |
[
"chakra-core",
"ChakraCore"
] | On Windows `AutoSystemInfo::GetVersionInfo` reads major/minor versions from module resource. It is used by `ByteCodeSerializer`, `SourceDynamicProfileManager` etc. to read jscript dll version info and store together with other data.
How do we make this cross-platform?
Can we change all the usage to use `CHAKRA_CORE_MAJOR_VERSION` etc. instead?
| linux: GetVersionInfo from resource | https://api.github.com/repos/chakra-core/ChakraCore/issues/197/comments | 3 | 2016-01-26T19:49:50Z | 2018-03-21T23:54:19Z | https://github.com/chakra-core/ChakraCore/issues/197 | 128,923,113 | 197 |
[
"chakra-core",
"ChakraCore"
] | A missing 'e' :)
| Typo in `Js::InternalPropertyIds::TypeOfPrototypObject' | https://api.github.com/repos/chakra-core/ChakraCore/issues/190/comments | 0 | 2016-01-26T01:18:35Z | 2016-01-26T20:02:21Z | https://github.com/chakra-core/ChakraCore/issues/190 | 128,690,585 | 190 |
[
"chakra-core",
"ChakraCore"
] | while testing to see if node-chakra supported ES6 modules, found a difference in errors.
Of course it would be better if there weren't an error.
Reported first to Microsoft/Node; they said I should make a error here since apparently the error text comes from the engine. https://github.com/Microsoft/node/issues/15#issuecomment-174741458 and they've already made a work around to bypass unit tests that fail for similar reason.
Sample Code...
```
//------ main.js ------
import * as lib from 'lib';
console.log(lib.square(11)); // 121
console.log(lib.diag(4, 3)); // 5
```
```
//------ lib.js ------
export const sqrt = Math.sqrt;
export function square(x) {
return x * x;
}
export function diag(x, y) {
return sqrt(square(x) + square(y));
}
//------ main.js ------
import { square, diag } from 'lib';
console.log(square(11)); // 121
console.log(diag(4, 3)); // 5
```
Output
```
M:\javascript\module-test>"H:\dev2\nodejs (chakracore)\node" main.js
SyntaxError: Syntax error
at tryWrapper (module.js:31:5)
at Module.prototype._compile (module.js:397:3)
at Module._extensions[.js] (module.js:432:3)
at Module.prototype.load (module.js:367:3)
at Module._load (module.js:324:5)
at Module.runMain (module.js:457:3)
at startup (node.js:139:11)
at Anonymous function (node.js:1001:3)
```
Not very informative error; nodeJS with V8 Usually outputs the source line in question... as in
NodeJS (V8)
```
M:\javascript\module-test>h:\dev2\nodejs\node main.js
M:\javascript\module-test\main.js:2
import * as lib from 'lib';
^^^^^^
SyntaxError: Unexpected token import
at exports.runInThisContext (vm.js:53:16)
at Module._compile (module.js:374:25)
at Object.Module._extensions..js (module.js:405:10)
at Module.load (module.js:344:32)
at Function.Module._load (module.js:301:12)
at Function.Module.runMain (module.js:430:10)
at startup (node.js:141:18)
at node.js:1003:3
```
| Failure to report line of error | https://api.github.com/repos/chakra-core/ChakraCore/issues/189/comments | 7 | 2016-01-26T00:55:56Z | 2018-02-22T00:22:49Z | https://github.com/chakra-core/ChakraCore/issues/189 | 128,687,037 | 189 |
[
"chakra-core",
"ChakraCore"
] | This [blog](http://www.viva64.com/en/b/0370/) discusses a number of issues the PVS tool found. Some look like real bugs. Please investigate and fix or assign to the appropriate area expert.
| Investigate static analysis findings from PVS | https://api.github.com/repos/chakra-core/ChakraCore/issues/180/comments | 1 | 2016-01-22T17:02:50Z | 2016-03-26T02:39:10Z | https://github.com/chakra-core/ChakraCore/issues/180 | 128,199,247 | 180 |
[
"chakra-core",
"ChakraCore"
] | I would like to start a discussion for adding few Memory specific APIs in JSRT:
- JSRT currently has [JsSetRuntimeBeforeCollectCallback](https://github.com/Microsoft/ChakraCore/wiki/JsSetRuntimeBeforeCollectCallback) API that lets host set a callback that gets called **before** GarbageCollection happens. It would be good to have an equivalent `JsSetRuntimeAfterCollectCallback` API that will let host set a callback that gets called **after** GC happens.
- JSRT has [JsGetRuntimeMemoryUsage](https://github.com/Microsoft/ChakraCore/wiki/JsGetRuntimeMemoryUsage) API that retrieves memory usage of a runtime. It would be good to expose more details of memory usage metrics like total vs. used vs. available heap size, physical size, etc.
A good example where these APIs can be useful would be to make native node add-ons like [gc-stats](https://www.npmjs.com/package/gc-stats) and [memwatch-next](https://www.npmjs.com/package/memwatch-next) work with node+chakracore.
| Memory related APIs in JSRT | https://api.github.com/repos/chakra-core/ChakraCore/issues/179/comments | 16 | 2016-01-22T15:57:52Z | 2016-03-12T14:51:45Z | https://github.com/chakra-core/ChakraCore/issues/179 | 128,186,180 | 179 |
[
"chakra-core",
"ChakraCore"
] | `Math.round` is implemented like `Math.floor(x + 0.5)` seems, and so is buggy for some values:
`Math.round(0.5 - Number.EPSILON / 4)` - should give 0, not 1
`Math.round(1 / Number.EPSILON + 1)` - should give `1 / Number.EPSILON + 1`
`Math.round(-(1 / Number.EPSILON + 1))` - should give `1 / Number.EPSILON + 1`
Actually, there is no need to "round" values which has absolute value >= `1 / Number.EPSILON`.
see https://github.com/tc39/test262/blob/26e6fd7c1779a63913cc7720cbc6c87b3b7b3285/test/built-ins/Math/round/S15.8.2.15_A7.js
| ARM JIT: `Math.round` is buggy for integers between 2**52+1 and 2**53-1 | https://api.github.com/repos/chakra-core/ChakraCore/issues/178/comments | 8 | 2016-01-22T15:29:49Z | 2018-05-02T22:30:03Z | https://github.com/chakra-core/ChakraCore/issues/178 | 128,179,223 | 178 |
[
"chakra-core",
"ChakraCore"
] | To demonstrate the capabilities of our analyzer, we regularly perform analysis of open source projects. We had recently checked the ChakraCore project.
Here is the link to the article about it: http://www.viva64.com/en/b/0370/
Official page of the analyzer: http://www.viva64.com/en/pvs-studio/
If you have any questions, or if you are interested in the evaluation of our static analyzer or in any other source code quality control services that our company provides, please contact us at support@viva64.com.
| Static analysis of ChakraCore with PVS-Studio | https://api.github.com/repos/chakra-core/ChakraCore/issues/177/comments | 2 | 2016-01-22T11:44:33Z | 2016-01-29T14:30:05Z | https://github.com/chakra-core/ChakraCore/issues/177 | 128,139,819 | 177 |
[
"chakra-core",
"ChakraCore"
] | See daily build table at https://github.com/Microsoft/ChakraCore/wiki/Build-Status#disablejit-builds
Originally opened in https://github.com/Microsoft/ChakraCore/issues/112, all but ARM have been fixed.
Build errors:
```
05:14:13
Chakra.Runtime.Language.lib(arm_Thunks.obj) : error LNK2019: unresolved external symbol "private: static void * (__cdecl*__cdecl Js::DynamicProfileInfo::EnsureDynamicProfileInfo(class Js::ScriptFunction *))(class Js::RecyclableObject *,struct Js::CallInfo,...)" (?EnsureDynamicProfileInfo@DynamicProfileInfo@Js@@CAP6APAXPAVRecyclableObject@2@UCallInfo@2@ZZPAVScriptFunction@2@@Z) referenced in function "public: static void * __cdecl Js::DynamicProfileInfo::EnsureDynamicProfileInfoThunk(class Js::RecyclableObject *,struct Js::CallInfo,...)" (?EnsureDynamicProfileInfoThunk@DynamicProfileInfo@Js@@SAPAXPAVRecyclableObject@2@UCallInfo@2@ZZ) [d:\j\workspace\Microsoft_ChakraCore\daily_disablejit_arm_debug\bin\ChakraCore\ChakraCore.vcxproj]
05:14:13 Chakra.Runtime.Language.lib(arm_Thunks.obj) : error LNK2019: unresolved external symbol "private: static void * (__cdecl*__cdecl Js::InterpreterStackFrame::EnsureDynamicInterpreterThunk(class Js::ScriptFunction *))(class Js::RecyclableObject *,struct Js::CallInfo,...)" (?EnsureDynamicInterpreterThunk@InterpreterStackFrame@Js@@CAP6APAXPAVRecyclableObject@2@UCallInfo@2@ZZPAVScriptFunction@2@@Z) referenced in function "public: static void * __cdecl Js::InterpreterStackFrame::DelayDynamicInterpreterThunk(class Js::RecyclableObject *,struct Js::CallInfo,...)" (?DelayDynamicInterpreterThunk@InterpreterStackFrame@Js@@SAPAXPAVRecyclableObject@2@UCallInfo@2@ZZ) [d:\j\workspace\Microsoft_ChakraCore\daily_disablejit_arm_debug\bin\ChakraCore\ChakraCore.vcxproj]
05:14:13 d:\j\workspace\Microsoft_ChakraCore\daily_disablejit_arm_debug\Build\VcBuild.NoJIT\bin\arm_debug\ChakraCore.dll : fatal error LNK1120: 2 unresolved externals [d:\j\workspace\Microsoft_ChakraCore\daily_disablejit_arm_debug\bin\ChakraCore\ChakraCore.vcxproj]
```
| Daily builds of DisableJIT (ARM) are broken. | https://api.github.com/repos/chakra-core/ChakraCore/issues/169/comments | 0 | 2016-01-21T20:03:01Z | 2016-02-02T19:41:52Z | https://github.com/chakra-core/ChakraCore/issues/169 | 128,007,854 | 169 |
[
"chakra-core",
"ChakraCore"
] | Current usage of `uintptr` and `uintptr_t` separately fails on cross platform.
Option 1) fix `uintptr` typedef for other platforms
Option 2) use only `uintptr_t`
Opinions ?
| Replace all the instances of uintptr to uintptr_t | https://api.github.com/repos/chakra-core/ChakraCore/issues/168/comments | 3 | 2016-01-21T19:56:35Z | 2016-02-02T01:38:46Z | https://github.com/chakra-core/ChakraCore/issues/168 | 128,006,638 | 168 |
[
"chakra-core",
"ChakraCore"
] | Example case:
``` js
(function() {
var resolve, reject;
var p = new Promise(function(res, rej) {
resolve = res;
reject = rej;
});
p.then(function(val) {
echo('The result is ' + val); // 'echo' is host-provided to output to console
});
try {
resolve(10);
}
catch (ex) {
echo('Failed to resolve: ' + ex.toString());
echo(typeof ex);
}
})();
```
If this code is evaluated and `JsSetPromiseContinuationCallback` has not been called, the failure case (`catch` branch) is invoked, and the following is output:
```
Failed to resolve: function() {
[native code]
}
function
```
The thrown thing appears to be the resolve function itself instead of a meaningful error. A meaningful error should be thrown instead, e.g., `TypeError: Promises may not be executed because the host has not provided a continuation callback in which to enqueue pending tasks.`
| JsRT: When calling resolve, the resolve function is thrown if JsSetPromiseContinuationCallback hasn't been called | https://api.github.com/repos/chakra-core/ChakraCore/issues/167/comments | 2 | 2016-01-21T19:50:57Z | 2017-07-14T16:18:04Z | https://github.com/chakra-core/ChakraCore/issues/167 | 128,005,608 | 167 |
[
"chakra-core",
"ChakraCore"
] | In `jenkins.check_copyright.sh`, see the following line:
``` sh
xargs -I % sh -c "echo 'Check Copyright > Checking %'; python jenkins.check_copyright.py % > $ERRFILETEMP; if [ \$? -ne 0 ]; then cat $ERRFILETEMP >> $ERRFILE; fi"
```
In PR #51 @goyakin suggested modifying this line like so:
> Did you consider using `||` instead of the `if` condition at the end? You can do:
>
> `python jenkins.check_copyright.py % > $ERRFILETEMP || cat $ERRFILETEMP >> $ERRFILE`
>
> instead.
Additionally, in `jenkins.check_copyright.py`, @goyakin recommended the following change:
``` python
for x in range(0,len(copyright_lines)):
```
> Since we're using `x` to retrieve the next item from regexes, why not iterate through regexes using `for regex in regexes:` instead?
| Reduce the logic in the Copyright Check | https://api.github.com/repos/chakra-core/ChakraCore/issues/166/comments | 2 | 2016-01-21T19:33:30Z | 2016-03-09T20:15:50Z | https://github.com/chakra-core/ChakraCore/issues/166 | 128,002,107 | 166 |
[
"chakra-core",
"ChakraCore"
] | ``` js
print('not early');
let undefined;
```
- Expected: Syntax error with nothing printed.
- Actual: not early is printed, then Syntax error is thrown.
See [GDI step 5.c+d](http://tc39.github.io/ecma262/#sec-globaldeclarationinstantiation).
| `let undefined` in global scope should be an early Syntax error | https://api.github.com/repos/chakra-core/ChakraCore/issues/165/comments | 5 | 2016-01-21T19:31:21Z | 2016-02-19T18:20:09Z | https://github.com/chakra-core/ChakraCore/issues/165 | 128,001,684 | 165 |
[
"chakra-core",
"ChakraCore"
] | After applying the fix (#150) of issue #143,
`.\ch.exe -Dump:Encoder ..\..\..\..\test\benchmarks\Octane\pdfjs.js`
produces wrong output for MultiBrInstr IR instructions, see below for an example (x64debug).
```
GLOBOPT INSTR: MultiBr $L54 $L55 $L56 $L57 $L58 $L53 , s38[LikelyCanBeTaggedValue_String].var #0037
1D8A22781FF s576(r9).u32 = MOV [s38(r8)[LikelyCanBeTaggedValue_String].var+24].u32
1D8A2278203 s577(r11).u32 = MOV 4384 (0x1120).u32
1D8A2278209 BT s577(r11).u32, s576(r9).u32
1D8A227820D JAE $L294
1D8A2278213 TEST s576(r9).u32, -32 (0xFFFFFFE0).u32
1D8A227821A JNE $L294
1D8A2278220 s578(r9).u64 = MOV &$L239.u64
1D8A227822A s579(r11).u64 = MOV &$L240.u64
1D8A2278234 s580<-72>.var = MOV s580(r8).var
1D8A2278238 arg3(s584)(r8).u64 = MOV s579(r11).u64
1D8A227823B arg2(s585)(rdx).u64 = MOV 0x01E0A3904518 (Unknown).u64
1D8A2278245 s580(r11).var = MOV s580<-72>.var
1D8A2278249 arg1(s586)(rcx).var = MOV s580(r11).var
1D8A227824C s587(rax).u64 = MOV Op_SwitchStringLookUp.u64
1D8A2278256 s582(rax).u64 = CALL s587(rax).u64
1D8A2278259 JMP $L1418414592 $L-1283968840 $L-1958215680 $L1291845622 $L1289128769 $L28 , s581(rax).u64
```
Notice that the last JMP machine instruction still dumps (wrong) labels. Instead, it should just be
`JMP s581(rax).u64`.
| MultiBrInstr IR instructions are not correctly dumped after lowered to JMP/B machine instructions | https://api.github.com/repos/chakra-core/ChakraCore/issues/162/comments | 0 | 2016-01-21T15:23:03Z | 2016-02-02T19:42:08Z | https://github.com/chakra-core/ChakraCore/issues/162 | 127,948,417 | 162 |
[
"chakra-core",
"ChakraCore"
] | Some are named using CamelCase others are lower case. This is very annoying.
| Why there is a mix of filenames? | https://api.github.com/repos/chakra-core/ChakraCore/issues/161/comments | 11 | 2016-01-21T14:07:18Z | 2016-02-19T00:58:36Z | https://github.com/chakra-core/ChakraCore/issues/161 | 127,931,283 | 161 |
[
"chakra-core",
"ChakraCore"
] | Is there a reason not to use bool type? Isn't ChakraCore implemented in C++?
| s/BOOL/bool | https://api.github.com/repos/chakra-core/ChakraCore/issues/160/comments | 14 | 2016-01-21T13:34:47Z | 2016-03-21T18:40:19Z | https://github.com/chakra-core/ChakraCore/issues/160 | 127,925,645 | 160 |
[
"chakra-core",
"ChakraCore"
] | SimplePropertyDescriptor const JavascriptLibrary::SharedFunctionPropertyDescriptors[2] =
{
SimplePropertyDescriptor(BuiltInPropertyRecords::prototype, PropertyWritable),
SimplePropertyDescriptor(BuiltInPropertyRecords::name, PropertyConfigurable | PropertyWritable)
};
| Function.name property is non-writable. It should be initialized as such. | https://api.github.com/repos/chakra-core/ChakraCore/issues/153/comments | 7 | 2016-01-20T20:28:40Z | 2016-02-02T19:42:55Z | https://github.com/chakra-core/ChakraCore/issues/153 | 127,776,833 | 153 |
[
"chakra-core",
"ChakraCore"
] | This was originally mentioned by @caitp [here](https://github.com/Microsoft/ChakraCore/issues/27#issuecomment-172001001) and @bterlson added the "Accepting PRs" label, but I think an additional label that both indicates _and_ encourages a new contributor to dig in would be a helpful distinction. There are many different ways this label is written, a quick ask on Twitter came up with:
- starter
- easy win
- first-timers-only (which has a website: http://www.firsttimersonly.com)
- easy, moderate, hard (which is actually three labels)
- your-first-pr (this was recommended by @ashleygwilliams who I regard as a leader "opening up" open source)
And many others.
| Create label that indicates and encourages a new contributor to take on the issue | https://api.github.com/repos/chakra-core/ChakraCore/issues/151/comments | 15 | 2016-01-20T17:50:43Z | 2016-01-23T01:42:27Z | https://github.com/chakra-core/ChakraCore/issues/151 | 127,744,535 | 151 |
[
"chakra-core",
"ChakraCore"
] | In order to create signed JavaScript objects, you need to normalize data.
The JCS specification https://cyberphone.github.io/openkeystore/resources/docs/jcs.html#ECMAScript_Compatibility_Mode accomplish this "automatically" by relying on ES6 for property order (which Chakra implements), but also depends on the extended number formatting algorithm used in the Google V8 engine which after testing with 100 million of random and selected values appears to be used by Chrome, Firefox, and Safari as well as "node.js".
Browser test program:
http://webpki.org/ietf/es6numberbrowsertest.html
10 million value test file:
http://webpki.org/ietf/es6testfile.txt
Although JCS does not (a this stage) represent a standard, the core concept will most likely become a de-facto standard due to its simplicity.
| Make number serialization compatible with V8 (and new IETF spec draft) | https://api.github.com/repos/chakra-core/ChakraCore/issues/149/comments | 20 | 2016-01-20T06:56:58Z | 2023-03-22T08:48:46Z | https://github.com/chakra-core/ChakraCore/issues/149 | 127,618,330 | 149 |
[
"chakra-core",
"ChakraCore"
] | See tc39/test262#473
For example this should be a `SyntaxError`:
``` javascript
for (let x of 0, []) { }
```
| for-of loop incorrectly recognizes Expression grammar for iterable expression; should be AssignmentExpression | https://api.github.com/repos/chakra-core/ChakraCore/issues/147/comments | 4 | 2016-01-20T00:28:45Z | 2016-03-10T03:17:55Z | https://github.com/chakra-core/ChakraCore/issues/147 | 127,573,399 | 147 |
[
"chakra-core",
"ChakraCore"
] | The V8 team have started looking in to a "Strong Mode" subsection of JavaScript (https://developers.google.com/v8/experiments). I was wondering if there are any plans to include this is in ChakraCore?
| [FeatureRequest] Strong Mode | https://api.github.com/repos/chakra-core/ChakraCore/issues/146/comments | 4 | 2016-01-19T23:40:31Z | 2016-01-20T18:06:50Z | https://github.com/chakra-core/ChakraCore/issues/146 | 127,565,992 | 146 |
[
"chakra-core",
"ChakraCore"
] | ``` js
{
function foo() { }
function foo() { }
}
```
Expected: Early syntax error. Actual: no error, second function wins always near as I can tell.
Duplicate function names are allowed at top level but not in blocks. Spidermonkey [came across web compat issues](https://bugzilla.mozilla.org/show_bug.cgi?id=1235590) trying to implement this, so are going to go more slowly. V8 has it in Canary and will test out these semantics in their Beta channel. Hopefully if all goes well there we can fix this bug without worry.
| Duplicate function declarations in blocks should throw early error in sloppy mode | https://api.github.com/repos/chakra-core/ChakraCore/issues/144/comments | 4 | 2016-01-19T22:44:01Z | 2016-03-26T02:40:02Z | https://github.com/chakra-core/ChakraCore/issues/144 | 127,556,593 | 144 |
[
"chakra-core",
"ChakraCore"
] | I observed ch.exe crashes when running "ch.exe -Dump:Encoder ..\..\..\..\test\benchmarks\Octane\pdfjs.js". The crashes consistently happen regarding x64debug and x86debug builds.
| ch.exe crashes when running "ch.exe -Dump:Encoder ..\..\..\..\test\benchmarks\Octane\pdfjs.js" | https://api.github.com/repos/chakra-core/ChakraCore/issues/143/comments | 1 | 2016-01-19T22:41:48Z | 2016-02-02T19:45:30Z | https://github.com/chakra-core/ChakraCore/issues/143 | 127,556,175 | 143 |
[
"chakra-core",
"ChakraCore"
] | Currently JSRT headers are in .\lib\jsrt. Move them to a top-level folder to make it easier for JSRT users.
| Relayout JSRT headers to top-level \include folder | https://api.github.com/repos/chakra-core/ChakraCore/issues/141/comments | 2 | 2016-01-19T19:40:18Z | 2018-02-15T00:57:15Z | https://github.com/chakra-core/ChakraCore/issues/141 | 127,521,641 | 141 |
[
"chakra-core",
"ChakraCore"
] | The roadmap contains a point about the inclusion of ChakraCore to node.js.
Do you already have a more specific ETA for that?
| [Question] Integration to node.js | https://api.github.com/repos/chakra-core/ChakraCore/issues/140/comments | 2 | 2016-01-19T09:29:40Z | 2016-01-19T23:09:53Z | https://github.com/chakra-core/ChakraCore/issues/140 | 127,402,805 | 140 |
[
"chakra-core",
"ChakraCore"
] | ``` js
function i(o) { print(JSON.stringify(o)) }
function* test() {
try {
yield 1;
} finally {
yield 2;
}
yield 3;
}
function* wrap() {
yield* test();
yield 4;
}
iter = wrap();
i(iter.next()); // { value: 1, done: false }
i(iter.return(42)); // { value: 2, done: false }
i(iter.next()); // { value: 4, done: false }
i(iter.next()); // { value: undefined, done: true }
```
Expected is above. However in our implementation we give { value: 2, done: true} for the 2nd result. I believe spec says .return(42) should invoke .return(42) on the inner generator, whose signal is handled by try/finally and yields { done: false, value: 2 }, which is then yielded as-is in [step 5.c.viii](https://tc39.github.io/#sec-generator-function-definitions-runtime-semantics-evaluation) of yield *.
| Incorrect .return() result on generator with yield* to another generator with try/finally | https://api.github.com/repos/chakra-core/ChakraCore/issues/139/comments | 3 | 2016-01-19T02:34:33Z | 2016-04-14T00:45:53Z | https://github.com/chakra-core/ChakraCore/issues/139 | 127,351,632 | 139 |
[
"chakra-core",
"ChakraCore"
] | Repro:
``` js
function* test() {
try {
yield;
} catch (e) {
return;
}
}
function* wrap() {
yield* test();
yield 3;
}
var iter = wrap();
iter.next();
print(JSON.stringify(iter.throw(Error("fail"))));
```
Expected per spec is `iterator result object { value: undefined, done: true }` as yield\* has a return completion value when received is a throw completion. However, v8/sm do differently and https://github.com/tc39/ecma262/issues/293 proposes changing the expected result to `{value: 3, done: false }` by returning a normal completion for this case.
| Incorrect .throw() result on generator with yield* to another generator with try/catch | https://api.github.com/repos/chakra-core/ChakraCore/issues/137/comments | 10 | 2016-01-19T00:28:00Z | 2016-04-14T00:46:15Z | https://github.com/chakra-core/ChakraCore/issues/137 | 127,337,994 | 137 |
[
"chakra-core",
"ChakraCore"
] | Current JsGetValueType only recognizes high level types. Improve it to recognize other types like RegExp, Date, Map, Set, etc.
| JSRT: Improve JsGetValueType API | https://api.github.com/repos/chakra-core/ChakraCore/issues/135/comments | 13 | 2016-01-18T07:19:34Z | 2016-11-02T22:52:21Z | https://github.com/chakra-core/ChakraCore/issues/135 | 127,168,103 | 135 |
[
"chakra-core",
"ChakraCore"
] | I'm trying to implement js callbacks (à la [node.js fs API](https://nodejs.org/api/fs.html) ) using async/await in C#, but I'm having difficulties due to threading. This is my situation: I have a method
``` c#
async Task<string> ReadFile(string path)
{
return await DoWhatever(path);
}
```
which I would like to use in a non blocking manner like this:
``` js
readFile(path, (err, content) =>
{
trace(content);
});
trace('Hello, World!');
```
For this reason I set up my context like this:
``` c#
global.SetProperty(JavaScriptPropertyId.FromString("readFile"), JavaScriptValue.CreateFunction((JavaScriptValue callee, bool isConstructCall, JavaScriptValue[] arguments, ushort argumentCount, IntPtr callbackData) =>
{
var args = arguments.Skip(1);
var path = args.First().ToString();
var callback = args.Skip(1).First();
var task = ReadTextAsync(path);
task.ContinueWith((content) =>
{
JavaScriptContext.Current = context; // This is the incriminating line
if (task.Status == TaskStatus.RanToCompletion)
{
callback.CallFunction(JavaScriptValue.Undefined, JavaScriptValue.FromString(task.Result));
}
else
{
callback.CallFunction(JavaScriptValue.False);
}
});
return JavaScriptValue.Undefined;
}), true);
```
If I omit that line, I get an exception because there is no current context set, but if I put that line, I get an exception about the code being executed in another thread, which is apparently illegal. What can I do? I've already tried doing `.ContinueWith(..., TaskScheduler.FromCurrentSynchronizationContext());`, but then I get an exception because the continuation cannot be run from the same scheduler.
| Implementing js-style callbacks in C# using async/await | https://api.github.com/repos/chakra-core/ChakraCore/issues/134/comments | 8 | 2016-01-17T22:46:32Z | 2016-03-13T10:35:28Z | https://github.com/chakra-core/ChakraCore/issues/134 | 127,129,955 | 134 |
[
"chakra-core",
"ChakraCore"
] | Hello,
how would one approach creating a ES6 class using the JSRT C++ API? I've looked through the sample codes, no luck tho.
Thanks
| Add ability to create an ES6 class using JSRT APIs | https://api.github.com/repos/chakra-core/ChakraCore/issues/132/comments | 6 | 2016-01-17T00:42:11Z | 2016-01-25T06:43:50Z | https://github.com/chakra-core/ChakraCore/issues/132 | 127,066,043 | 132 |
[
"chakra-core",
"ChakraCore"
] | ```
18:11:38 2>ERROR: Test failed to run correctly: diffs from baseline (d:\j\workspace\Microsoft_ChakraCore\daily_slow_x64_debug\test\AsmJs\basicMath.baseline):
18:11:38 2> ch.exe -DumpOnCrash -WERExceptionSupport -ExtendedErrorStackForTestHost -maxInterpretCount:1 -maxSimpleJitRunCount:1 -bgjit- -dynamicprofilecache:profile.dpl.UnnamedTest1835 -testtrace:asmjs -simdjs -maic:0 d:\j\workspace\Microsoft_ChakraCore\daily_slow_x64_debug\test\AsmJs\basicMath.js >testout1721 2>&1
18:11:38 2>ERROR: name of output file: d:\j\workspace\Microsoft_ChakraCore\daily_slow_x64_debug\test\AsmJs\testout1721; size: 670458; creation: Sat Jan 16 02:00:50 2016, last access: Sat Jan 16 02:00:50 2016, now: Sat Jan 16 02:00:53 2016
18:11:38 2>ERROR: bad output file follows ============
...<clipped>
18:11:38 4>ui a[0](undefined) + 4294967295 = -1
18:11:38 4>ui a[0](undefined) - 4294967295 = 1
18:11:38 4>ui a[0](undefined) * 1048575 = 0
18:11:38 4>ASSERTION 5804: (d:\j\workspace\Microsoft_ChakraCore\daily_slow_x64_debug\lib\Backend\Opnd.cpp, line 1377) m_type != TyUint32 || (value >= 0 && value <= UINT32_MAX)
18:11:38 4> Failure: (m_type != TyUint32 || (value >= 0 && value <= 0xffffffffui32))
18:11:38 4>dump filename C:\Users\DOTNET~1\AppData\Local\Temp\\CH_5804_1336.dmp
18:11:38 4>FATAL ERROR: ch.exe failed due to exception code c0000420
18:11:38 4>ERROR: end of bad output file ============
...
18:11:38 Summary: d:\j\workspace\Microsoft_ChakraCore\daily_slow_x64_debug\test had 1714 tests; 1 failures
```
See: http://dotnet-ci.cloudapp.net/job/Microsoft_ChakraCore/job/daily_slow_x64_debug/1/
| x64_debug -includeSlow (one of the daily builds) fails a unit test. | https://api.github.com/repos/chakra-core/ChakraCore/issues/129/comments | 2 | 2016-01-16T03:21:26Z | 2016-02-02T19:45:51Z | https://github.com/chakra-core/ChakraCore/issues/129 | 126,997,177 | 129 |
[
"chakra-core",
"ChakraCore"
] | <pre>/// <summary>
/// Deletes an object's property.
/// </summary>
/// <remarks>
/// Requires an active script context.
/// </remarks>
/// <param name="object">The object that contains the property.</param>
/// <param name="propertyId">The ID of the property.</param>
/// <param name="useStrictRules">The property set should follow strict mode rules.</param>
/// <param name="result">Whether the property was deleted.</param>
/// <returns>
/// The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
STDAPI_(JsErrorCode)
JsDeleteProperty(
_In_ JsValueRef object,
_In_ JsPropertyIdRef propertyId,
_In_ bool useStrictRules,
_Out_ JsValueRef *result);</pre>
result should be the <b>bool</b> type?
| a question about JsDeleteProperty | https://api.github.com/repos/chakra-core/ChakraCore/issues/128/comments | 3 | 2016-01-16T02:23:54Z | 2016-01-23T03:18:40Z | https://github.com/chakra-core/ChakraCore/issues/128 | 126,994,648 | 128 |
[
"chakra-core",
"ChakraCore"
] | Does Chakra exposes parser information?
For example, assuming I have script like this:
``` javascript
function foo(x, y) {
return x + y;
}
```
I want to be able to get argument names ("x" and "y").
Alternatively, assuming I have script like bellow and already ran it and got "f1" as a value. Can I get argument names of f1 from runtime?
``` javascript
var f1 =function foo(x, y) {
return x + y;
}
```
| Does Chakra expose parser information? | https://api.github.com/repos/chakra-core/ChakraCore/issues/125/comments | 2 | 2016-01-15T21:30:20Z | 2016-01-17T06:04:15Z | https://github.com/chakra-core/ChakraCore/issues/125 | 126,961,786 | 125 |
[
"chakra-core",
"ChakraCore"
] | See ScriptFunction constructor. Only the background-jit-stats related updates should be made inside the BGJIT_STATS macro scope
| Setting whether a function body's native entry point is used should be BGJIT_STATS agnostic | https://api.github.com/repos/chakra-core/ChakraCore/issues/122/comments | 2 | 2016-01-15T18:48:18Z | 2018-07-03T20:20:12Z | https://github.com/chakra-core/ChakraCore/issues/122 | 126,932,843 | 122 |
[
"chakra-core",
"ChakraCore"
] | String.prototype.lastIndexOf is broken when passed with the Unicode characters and second argument specified.
``` javascript
'abcあい'.lastIndexOf('あい', 1)
```
expected: -1
actual: 3
According to [ECMA 21.1.3.9](http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype.lastindexof) - the `position` argument is used for the end of the string to look _left_ from - ie, it is indeed spec-compliant behavior for `'abcあい'.lastIndexOf('あい', n)` to return `-1` when `n` is less than `'abcあい'.indexOf('あい')`.
| String.prototype.lastIndexOf broken | https://api.github.com/repos/chakra-core/ChakraCore/issues/120/comments | 4 | 2016-01-15T12:11:08Z | 2016-01-20T21:52:43Z | https://github.com/chakra-core/ChakraCore/issues/120 | 126,861,381 | 120 |
[
"chakra-core",
"ChakraCore"
] | There's no need to have the trigger phrases `daily` or `dailys` (regex: `dailys?`) when `dailies` works and doesn't accidentally get matched for individual test triggers.
| The trigger regex 'daily.*' for all dailies also matches 'daily_...' causing extra builds to be triggered. | https://api.github.com/repos/chakra-core/ChakraCore/issues/119/comments | 0 | 2016-01-15T09:30:47Z | 2016-02-02T19:44:09Z | https://github.com/chakra-core/ChakraCore/issues/119 | 126,836,725 | 119 |
[
"chakra-core",
"ChakraCore"
] | https://github.com/Microsoft/ChakraCore/wiki/Build-Status#legacy-builds
It seems specific to x64_debug.
While we investigate why they are timing out after 60s (despite running individually in under 10s), we will disable these tests in this configuration.
Tests I've seen affected so far:
```
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\typedarray\allocation.js
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\typedarray\allocation2.js
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\bailout\bailout7.js
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\bailout\bailout-argobj.js
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\bailout\bailout-args.js
d:\j\workspace\Private\Microsoft_ChakraCore_daily_x64_debug\test\bailout\bailout-throw.js
```
Edit 3/7/16: We did not end up disabling the tests because we wanted to monitor the failures and having that build flavor green was not high priority. The problem seems to have spontaneously improved. We will monitor for a while and re-evaluate whether there is any further action to be taken on this issue.
| [Test failure] [Daily] [Dev12 x64_debug] Test timeouts are causing the legacy daily build to fail on x64_debug | https://api.github.com/repos/chakra-core/ChakraCore/issues/115/comments | 11 | 2016-01-15T00:59:46Z | 2016-06-07T22:00:30Z | https://github.com/chakra-core/ChakraCore/issues/115 | 126,784,024 | 115 |
[
"chakra-core",
"ChakraCore"
] | See table at: https://github.com/Microsoft/ChakraCore/wiki/Build-Status#disablejit-builds
Confirmed the compile error locally.
```
E:\dev\ChakraCore\lib\Runtime\Language\JavascriptStackWalker.h(229): error C3646: 'GetCachedInternalFrameInfo': unknown override specifier [E:\dev\ChakraCore\lib\Runtime\Base\Chakra.Runtime.Base.vcxproj]
E:\dev\ChakraCore\lib\Runtime\Language\JavascriptStackWalker.h(229): error C2059: syntax error: '(' [E:\dev\ChakraCore\lib\Runtime\Base\Chakra.Runtime.Base.vcxproj]
E:\dev\ChakraCore\lib\Runtime\Language\JavascriptStackWalker.h(229): error C2334: unexpected token(s) preceding '{'; skipping apparent function body [E:\dev\ChakraCore\lib\Runtime\Base\Chakra.Runtime.Base.vcxproj]
E:\dev\ChakraCore\lib\Runtime\Language\JavascriptStackWalker.h(330): error C3646: 'lastInternalFrameInfo': unknown override specifier [E:\dev\ChakraCore\lib\Runtime\Base\Chakra.Runtime.Base.vcxproj]
E:\dev\ChakraCore\lib\Runtime\Language\JavascriptStackWalker.h(330): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int [E:\dev\ChakraCore\lib\Runtime\Base\Chakra.Runtime.Base.vcxproj]
```
Looks like it might be related to https://github.com/Microsoft/ChakraCore/commit/c6c4de4104526e4cb5203a73394d3345a2fa0476 by @rajatd
| Daily builds of DisableJIT (x86, x64) are broken. | https://api.github.com/repos/chakra-core/ChakraCore/issues/112/comments | 1 | 2016-01-14T23:59:18Z | 2016-01-21T20:29:42Z | https://github.com/chakra-core/ChakraCore/issues/112 | 126,776,590 | 112 |
[
"chakra-core",
"ChakraCore"
] | This is for general discussions on the cross-platfrom effort. Please open individual issues for tasks clearly identified from this discussion, or PRs if they are small and you can do them quickly.
Please see the [Roadmap](https://github.com/Microsoft/ChakraCore/wiki/Roadmap#enhancing-host--platform-support) for our cross-platform checklist and progress.
Related issues:
- [ ] #197
- [ ] #198
- [ ] #200
See https://github.com/caitp/ChakraCore/issues/1 for some examples of work items we might want to consider.
| [Discussion] Linux / Cross-platform planning | https://api.github.com/repos/chakra-core/ChakraCore/issues/111/comments | 31 | 2016-01-14T23:53:15Z | 2016-09-07T20:25:08Z | https://github.com/chakra-core/ChakraCore/issues/111 | 126,775,808 | 111 |
[
"chakra-core",
"ChakraCore"
] | Tests use legacy build architecture and type terms for exclusion tags:
- `exclude_amd64`
- `exclude_chk`
- `exclude_fre`
[`test/runtests.cmd`](https://github.com/Microsoft/ChakraCore/blob/master/test/runtests.cmd) uses the new terms as input but shims them to the old terms for the exclusion tags. It would be nicer to change all the rlexe.xml files to use the new terms and remove the shim from `runtests.cmd`.
New tags should be:
- `exclude_x64`
- `exclude_debug`
- `exclude_test`
----
@dilijev: Update 12/18/2016
Due to the pervasive use of the old tag names across multiple dev branches and both internally and externally, the initial work item here should be to add support for the new tags, and ensure that we continue to support the old tags.
At the time of the PR which adds support, all of the existing uses of the old terms should be updated to the new terms. New tests added via other branches which do not yet support the new terms will still use the old terms, so supporting both for a time is necessary.
This means any place we would exclude either the old or new tag, we must exclude both. For example, we must exclude BOTH `exclude_x64` (new) and `exclude_arm64` (old), and never only one of them.
At some point in the future (when all active development branches support the new terms), we will deprecate the use of the old terms and remove support for them. At that time, all remaining uses of the old terms will be replaced with the new terms and support will be dropped from the scripts.
See follow-up work item #2240. | rlexe.xml tags: add support for new build architecture and type terms | https://api.github.com/repos/chakra-core/ChakraCore/issues/110/comments | 4 | 2016-01-14T23:50:42Z | 2018-03-26T18:48:26Z | https://github.com/chakra-core/ChakraCore/issues/110 | 126,775,497 | 110 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.