eclipse / n4js Goto Github PK

This is the real problem!

git clone https://github.com/Eclipse/n4js.git
cd n4js
mvn clean verify
mvn clean deploy -Dlocal-snapshot-deploy-folder=/var/lib/my/folder/local-mvn-deploy-repository
class A {}
export public function* foo(req: A) { // removing export public fixes the problem 
    yield 5; // removing 5 fixes the problem
    req. // <-- content assist here ctrl+space
}
interface I {}

// case #1
class C {}
// case #2
//class C extends Object {}
// case #3
//class C extends N4Object {}
// case #4
//class C extends Object implements I {}

// compare how the following code behaves for each of the cases above:

C.n4type;
var c: C;
c.xyz123();
var v1: N4Object = c;

I.n4type;
var i: I;
i.xyz123();
var v2: N4Object = i;
class C {}
class D extends C {	
	// XPECT FIXME errors --> "super() must be explicitly called"
	constructor() {	}
}
class E extends C {
	constructor() {
		// XPECT FIXME errors --> "super() must be called before accessing this"
		var x = this;
		super();
	}
}

class F extends C {
	constructor() {
		var x = 5;
		super();
	}
}
class A {}
class B { // adding "extends A" here resolves the error
  constructor() {
    super(); // error: "super call is only allowed in derived constructor"
  }
}
var v: ~Object with { a:A, b:B }
var v: ~{ a:A, b:B }
var v: { a:A, b:B }
var v0: {function ()}
var v1: { function }
abstract class ABase {
    protected abstract static a();

    doA() {
        this.constructor.a();
    }
}

class A extends ABase {
    @Override
    protected static a() {
        console.log("doing a foo")
    }
    
    doSomething() {
        this.doA();
    }
}

class B extends ABase {
    @Override
    protected static a() {
        console.log("doing a bar")
    }
    
    doSomethingElse() {
        this.doA();
    }
}
type Name = string;
type callback = (int)=>string;
// XPECT noerrors --> 
type Name = string;

// XPECT errors --> "Type dog is not a recognized type" at "dog"
type Name = dog;
class A {}
> let a = new A();

> a.constructor
[Function: A]

> p = new Proxy(a, handler);
> p.constructor
[Function: A]

class A {}
class B {}

let p: Proxy<A>;
// XPECT noerrors -->
let a: A = p;
// XPECT errors --> "Proxy<A> is not a subtype of B"
let b: B = p;

class A {}
class B extends A {}
class C extends B {}
let c: C;

// Test 1a
// XPECT typeof 'p' --> B
let ol: ~Object with { m(B):void } = { void m(p ) {} } // p is any
ol;

// Test 1b
// X-PECT FIXME noerrors -->
// XPECT typeof 'p' --> union{B,C}
let ol1: ~Object with { m(B):void } = { void m(p = c) {} }
ol1;
let ol = {
    prop: "hello",

    // Test 2a
    // XPECT FIXME noerrors -->
    m1(p1 = this.prop) {},

    // Test 2b
    m2(p0, p1 = p0) {},
}
ol;
import {B} from "B";

export class A {
	static fieldA = 'some string';
}

let str: string = B.fieldB;

import {A} from "A";

export class B {
	static fieldB = A.fieldA;
}

!STACK 0
java.lang.RuntimeException: java.lang.IllegalArgumentException: wrong number of arguments
	at org.eclipse.xtext.service.MethodBasedModule.invokeMethod(MethodBasedModule.java:138)
	at org.eclipse.xtext.service.MethodBasedModule.configure(MethodBasedModule.java:68)
	at org.eclipse.xtext.service.CompoundModule.configure(CompoundModule.java:35)
	at org.eclipse.xtext.service.AbstractGenericModule.configure(AbstractGenericModule.java:33)
	at org.eclipse.xtext.ui.DefaultUiModule.configure(DefaultUiModule.java:134)
	at org.eclipse.n4js.n4jsx.ui.N4JSXUiModule.configure(N4JSXUiModule.java:140)
	at com.google.inject.spi.Elements$RecordingBinder.install(Elements.java:223)
	at com.google.inject.spi.Elements.getElements(Elements.java:101)
	at com.google.inject.spi.Elements.getElements(Elements.java:92)
	at com.google.inject.util.Modules$RealOverriddenModuleBuilder$1.configure(Modules.java:172)
	at com.google.inject.AbstractModule.configure(AbstractModule.java:59)
	at com.google.inject.spi.Elements$RecordingBinder.install(Elements.java:223)
	at com.google.inject.spi.Elements.getElements(Elements.java:101)
	at com.google.inject.internal.InjectorShell$Builder.build(InjectorShell.java:133)
	at com.google.inject.internal.InternalInjectorCreator.build(InternalInjectorCreator.java:103)
	at com.google.inject.Guice.createInjector(Guice.java:95)
	at com.google.inject.Guice.createInjector(Guice.java:72)
	at com.google.inject.Guice.createInjector(Guice.java:62)
	at org.eclipse.n4js.n4jsx.ui.internal.N4JSXActivator.createInjector(N4JSXActivator.java:74)
	at org.eclipse.n4js.n4jsx.ui.internal.N4JSXActivator.getInjector(N4JSXActivator.java:62)
	at org.eclipse.n4js.n4jsx.ui.N4JSXExecutableExtensionFactory.getInjector(N4JSXExecutableExtensionFactory.java:31)
	at org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory.create(AbstractGuiceAwareExecutableExtensionFactory.java:51)
	at org.eclipse.core.internal.registry.ConfigurationElement.createExecutableExtension(ConfigurationElement.java:262)
	at org.eclipse.core.internal.registry.ConfigurationElementHandle.createExecutableExtension(ConfigurationElementHandle.java:55)
	at org.eclipse.xtext.builder.impl.RegistryBuilderParticipant$DeferredBuilderParticipant.initDelegate(RegistryBuilderParticipant.java:182)
	at org.eclipse.xtext.builder.impl.RegistryBuilderParticipant$DeferredBuilderParticipant.getDelegate(RegistryBuilderParticipant.java:173)
	at org.eclipse.n4js.ui.building.N4JSGenerateImmediatelyBuilderState.findJSBuilderParticipant(N4JSGenerateImmediatelyBuilderState.java:257)
	at org.eclipse.n4js.ui.building.N4JSGenerateImmediatelyBuilderState.doUpdate(N4JSGenerateImmediatelyBuilderState.java:180)
	at org.eclipse.xtext.builder.builderState.AbstractBuilderState.update(AbstractBuilderState.java:116)
	at org.eclipse.xtext.builder.impl.XtextBuilder.doBuild(XtextBuilder.java:287)
	at org.eclipse.n4js.ui.building.N4JSBuildTypeTrackingBuilder.doBuild(N4JSBuildTypeTrackingBuilder.java:77)
	at org.eclipse.xtext.builder.impl.XtextBuilder.fullBuild(XtextBuilder.java:319)
	at org.eclipse.xtext.builder.impl.XtextBuilder.build(XtextBuilder.java:155)
	at org.eclipse.core.internal.events.BuildManager$2.run(BuildManager.java:735)
	at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:42)
	at org.eclipse.core.internal.events.BuildManager.basicBuild(BuildManager.java:206)
	at org.eclipse.core.internal.events.BuildManager.basicBuild(BuildManager.java:246)
	at org.eclipse.core.internal.events.BuildManager$1.run(BuildManager.java:301)
	at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:42)
	at org.eclipse.core.internal.events.BuildManager.basicBuild(BuildManager.java:304)
	at org.eclipse.core.internal.events.BuildManager.basicBuildLoop(BuildManager.java:360)
	at org.eclipse.core.internal.events.BuildManager.build(BuildManager.java:383)
	at org.eclipse.core.internal.events.AutoBuildJob.doBuild(AutoBuildJob.java:144)
	at org.eclipse.core.internal.events.AutoBuildJob.run(AutoBuildJob.java:235)
	at org.eclipse.core.internal.jobs.Worker.run(Worker.java:55)
Caused by: java.lang.IllegalArgumentException: wrong number of arguments
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.eclipse.xtext.service.MethodBasedModule.invokeMethod(MethodBasedModule.java:136)
	... 44 more

interface I {}

class C {
	public expectations: ~Object with {
        technicalContainer: I;
        technicalContents: Array<I>;
    } = {
        technicalContainer: null,
        technicalContents: [] // TODO mor-n4: infer this!
    };
}
class C {}

// [] should be inferred to Array<? extends C> XPECT FIXME noerrors -->
var x: ~Object with {prop: Array<? extends C>} = { prop: [] };

// works in simple case though XPECT noerrors -->
var empty:  Array<? extends C> = [];
function foo(arr: Array<string>) {
	var theArr: Array<string> = arr || [];
}
let arr1: Array<string> = []; // works
let arr2: Array<string> = ([]); // does not work
let arr3: Array<string> = 5<6 ? [] : []; // does not work
class Map<KeyT, ValueT> extends Object implements Iterable<Iterable2<KeyT, ValueT>> {
    public constructor(arg: Iterable<Iterable2<KeyT, ValueT>>?) {}

    @Override
    public [Symbol.iterator](): Iterator<Iterable2<KeyT,ValueT>> {return null;}
}

// XPECT FIXME noerrors --> "Array<Array<union{number,string}>> is not a structural subtype of Iterable<Iterable2<string,number>>?: #iterator failed: {function():Iterator<Array<union{number,string}>>} is not a subtype of {function():Iterator<Iterable2<string,number>>}." at "[['a', 1]]"
var map1: Map<string, number> = new Map<string, number>([['a', 1]]);

// XPECT noerrors --> "Workaround for the above issue."
var map: Map<string, number> = new Map<string, number>([['a', 1] as Iterable2<string, number>]);
class B { foo() {} }
function trans(a): B { return null; }

function processAs(arrA: Array<any>): void {
    // at the moment, Array<any> is inferred XPECT FIXME type of 'x' --> Array<B>
    // XPECT FIXME noerrors --> "Couldn't resolve reference to IdentifiableElement 'foo'." at "foo"
    arrA.map( a => trans(a) ).forEach( b => b.foo() );
    
    // work-around, for the time being:
    arrA.map( (a):B => trans(a) ).forEach( b => b.foo() );
};
Sources {
    source {
        "src", "src2"
    }
    external {
        "ext"
    }
    test {
        "tst"
    }
}

var abc: "A" | "B" | "C";
var ab: "A" | "B";
class A {
	const x = new B();
}

class B extends A {}
console.log(A.x instanceof B); // prints: false
class B extends A {}
class A {
	const x : B = new B();
}
console.log(A.x instanceof A);  // prints: false
console.log(A.x instanceof B);  // prints: true
// XPECT FIXME output --> true
class A {
	const x = new B();
}

class B extends A {}
console.log(A.x instanceof B);
<!--
THIRD-PARTY_PATH: project/relative/path/to.file
THIRD-PARTY_PATH: project/relative/path/to/folder/**
-->

export class A {
    public <V> method() : V { return null;  }
}
var x:A = new A().<A>method();

function <U> f1() :U { return null; }
var y:A = <A>f1();
export class A {
    public method<V>() : V { return null;  }
}
var x:A = new A().method<A>();

function f1<U>() :U { return null; }
var y:A = f1<A>();
export class A {
    // XPECT warnings --> "Java-styled generic methods are deprecated" at "<V>"
    public <V> method() : V { return null;  }
}
  // XPECT warnings --> "Java-styled parameterized method calls are deprecated" at "<A>"
var x:A = new A().<A>method();

  // XPECT warnings --> "Java-styled generic functions are deprecated" at "<V>"
function <U> f1() :U { return null; }

  // XPECT warnings --> "Java-styled parameterized function calls are deprecated" at "<A>"
var y:A = <A>f1();

export class A {
    // XPECT nowarnings -->
    public method<V>() : V { return null;  }
}
// XPECT nowarnings -->
var x:A = new A().method<A>();

// XPECT nowarnings -->
function f1<U>() :U { return null; }
// XPECT nowarnings -->
var y:A = f1<A>();
var a;
var a; // <-- error in N4JS but not in ES5
// in the entire following code, N4JS only shows a single error (which is too few)

// V8: error (on second a)
// Babel: error
var top_a;
let top_a; // <-- this is the only error that currently shows up properly in N4JS


// V8: error (on second a)
// Babel: error
function foo01() {
	var a;
	let a;
}


// V8: error (on first a)
// Babel: ok
function foo11() {
  {
    var a;
    let a;
  }
}


// V8: error (on first a)
// Babel: ok
function foo12() {
	if(true) {
		var a;
		let a;
	}
}


// V8: error (on first a)
// Babel: ok
function foo13() {
	for(;;) {
		var a;
		let a;
	}
}


// V8: two errors (see below)
// Babel: ok
function foo21() {
	{
		var a;
		{
			var b; // --> error in V8
			
			let a;
			let b;
			let c;
			{
				var c; // --> error in V8
			}
		}
	}
}


// V8: two errors (see below)
// Babel: ok
function foo22() {
	if(true) {
		var a;
		if(true) {
			var b; // --> error in V8
			
			let a;
			let b;
			let c;
			if(true) {
				var c; // --> error in V8
			}
		}
	}
}


// V8: two errors (see below)
// Babel: ok
function foo23() {
	for(;;) {
		var a;
		for(;;) {
			var b; // --> error in V8
			
			let a;
			let b;
			let c;
			for(;;) {
				var c; // --> error in V8
			}
		}
	}
}


// V8: one error (see below)
// Babel: ok
function foo31() {
	for(var a;;) {
		let a;
	}
	for(let b;;) {
		var b; // --> error in V8
	}
	for(let c;;) {
		let c;
	}
}
export public class C {
	b: B;
	d = new D();
	g() {
		this.b = this.d; // Error: any is not a subtype of B.
	}
}

abstract class B {}

class D extends B {
	protected c: C;
	f() {
		this.c.g(); // removing this line solves the error
	}
}
class D extends B {
	protected c: C;
	f() {
		this.c.g();
	}
}
class C {
	b: B;
	d  = new D();
	g() {
		this.b = this.d; // no error here
	}
}
abstract class B {}
export public class C {
	b: B;
	// at least correctly shown in outline view XPECT typeof d --> D
	d = new D();
	g() {
		// XPECT FIXME noerrors --> "any is not a subtype of B."
		this.b = this.d;
	}
}

abstract class B {}

class D extends B {
	protected c: C;
	f() {
		this.c.g();
	}
}
export public external class C {
	public string field;
}
export public class C {
	public string get field() {return null;}
	public set field(string p) {}
}
env.WORKSPACE=/media/data-2/jenkins_slave_home/workspace/multibranch_master-B3PDSWG7LQILACQEIB2YTGOQTSVJGT2JPZ6AQTIWZJGM6A3VJJ4Q

Setting project property: WORKSPACE -> /home/build

			<plugin>
				<!-- Executing the build as part of the integration test in a separate vm. -->
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>exec-maven-plugin</artifactId>
				<version>${codehaus-exec-maven-plugin.version}</version>
				<configuration>
					<systemProperties>
						<WORKSPACE>${WORKSPACE}</WORKSPACE>

		<!-- Profile workspace-to-userhome is automatically activated if the property WORKSPACE is not set.
			 As a fall-back it sets it to ${user.home}  -->
		<profile>
			<id>workspace-to-userhome</id>
			<activation>
				<property>
					<name>!WORKSPACE</name>
				</property>
			</activation>
			<properties>
				<WORKSPACE>${user.home}</WORKSPACE>
			</properties>
		</profile>

function tag(strings, p1, p2) {
  console.log(strings instanceof Array)
  console.log(typeof p1 == 'number')
  console.log(typeof p2 == 'number')
  return true;
}
// XPECT noerrors --> "string literals allow for embedded expressions" at "tag"
let x = tag`Hello ${1} world ${2*3}`;
console.log(typeof x == 'boolean')
class A {}
class B extends A {}

class Cls1 {
	field: A;
}
class Cls2 extends Cls1 {
	// XPECT noerrors --> "Type of field Cls2.field must equal type of overridden field Cls1.field." at "field"
	@Override field = new B();
}

eclipse / n4js Goto Github PK

n4js's Introduction

N4JS

Releases

Contribute

Eclipse Installer

Documentation

Participate

Build the N4JS IDE from command line

Publish maven-tooling org.eclipse.n4js.releng.util

License

n4js's People

Contributors

Stargazers

Watchers

Forkers

n4js's Issues

Acceptance Criteria:

Considerations

Acceptance Criteria

Considerations

Considerations

Acceptance Criteria

Acceptance Criteria

Acceptance Criteria

Acceptance Criteria

Acceptance Criteria

Acceptance Critera:

Test 1:

Test 2:

Acceptance criteria

Acceptance Criteria

AC

Array literals as values of an object literal with type expectation

Consider bounded wildcard as constraint solution in case of empty array literal

Using array literals with || (and similar nesting)

Inference of nested array literals with an expectation of IterableN

Better support for Array#map() (and similar methods in general), in particular chaining with Array#forEach(), etc.

Acceptance Criteria

Acceptance Criteria

Acceptance Criteria

Acceptance Criteria

Browser Runner Background

Considerations

Acceptance Criteria

Acceptance Criteria

Considerations

Acceptance Criteria:

Acceptance Criteria

Acceptance Criteria

Remarks

Acceptance Criteria

Xpect Tests

Notes

Redeclaration of var

Relation between var versus let/const

Acceptance Criteria

API project:

Impl project:

Acceptance criteria

Acceptance Criteria

Acceptance Criteria:

Recommend Projects

Recommend Topics

Recommend Org

Publish maven-tooling `org.eclipse.n4js.releng.util`

Using array literals with `||` (and similar nesting)

Better support for `Array#map()` (and similar methods in general), in particular chaining with `Array#forEach()`, etc.