jsgen: implement js backend

cmd/tools/vfmt.v

@@ -18,6 +18,7 @@ import (
 struct FormatOptions {
 	is_l       bool
 	is_c       bool
+	is_js	   bool
 	is_w       bool
 	is_diff    bool
 	is_verbose bool
@@ -51,6 +52,7 @@ fn main() {
 	args := util.join_env_vflags_and_os_args()
 	foptions := FormatOptions{
 		is_c: '-c' in args
+		is_js: '-js' in args
 		is_l: '-l' in args
 		is_w: '-w' in args
 		is_diff: '-diff' in args
@@ -200,7 +202,7 @@ fn (foptions &FormatOptions) post_process_file(file string, formatted_file_path
 		return
 	}
 	is_formatted_different := fc != formatted_fc
-	if foptions.is_c {
+	if foptions.is_c || foptions.is_js {
 		if is_formatted_different {
 			eprintln('File is not formatted: $file')
 			exit(2)

cmd/v/v.v

@@ -160,6 +160,13 @@ fn parse_args(args []string) (&pref.Preferences, string) {
 				res.out_name  = cmdline.option(args, '-o', '')
 				i++
 			}
+			'-b' {
+				b := pref.backend_from_string(cmdline.option(args, '-b', 'c')) or {
+					continue
+				}
+				res.backend = b
+				i++
+			}
 			else {
 				mut should_continue := false
 				for flag_with_param in list_of_flags_with_param {

vlib/v/ast/ast.v

@@ -56,6 +56,7 @@ pub:
 	val    string
 	is_raw bool
 	is_c   bool
+	is_js  bool
 	pos    token.Position
 }
 
@@ -146,6 +147,7 @@ pub:
 	pub_pos     int // pub:
 	pub_mut_pos int // pub mut:
 	is_c        bool
+	is_js       bool
 	is_union    bool
 }
 
@@ -187,6 +189,7 @@ pub:
 	is_method     bool
 	rec_mut       bool // is receiver mutable
 	is_c          bool
+	is_js		  bool
 	no_body       bool // just a definition `fn C.malloc()`
 	is_builtin    bool // this function is defined in builtin/strconv
 	pos           token.Position
@@ -208,6 +211,7 @@ mut:
 	args               []CallArg
 	expected_arg_types []table.Type
 	is_c               bool
+	is_js			   bool
 	or_block           OrExpr
 	left_type          table.Type // type of `user`
 	receiver_type      table.Type // User
@@ -301,6 +305,7 @@ pub struct Ident {
 pub:
 	value    string
 	is_c     bool
+	is_js    bool
 	tok_kind token.Kind
 	mod      string
 	pos      token.Position

vlib/v/ast/str.v

@@ -36,6 +36,9 @@ pub fn (node &FnDecl) str(t &table.Table) string {
 	if node.is_c {
 		name = 'C.$name'
 	}
+	if node.is_js {
+		name = 'JS.$name'
+	}
 	f.write('fn ${receiver}${name}(')
 	for i, arg in node.args {
 		// skip receiver

vlib/v/builder/builder.v

@@ -12,6 +12,7 @@ import (
 	v.parser
 	v.scanner
 	v.gen
+	v.gen.js
 	v.gen.x64
 )
 
@@ -27,6 +28,7 @@ mut:
 	parsed_files        []ast.File
 	global_scope        &ast.Scope
 	out_name_c          string
+	out_name_js			string
 }
 
 pub fn new_builder(pref &pref.Preferences) Builder {
@@ -44,64 +46,6 @@ pub fn new_builder(pref &pref.Preferences) Builder {
 	}
 }
 
-pub fn (b mut Builder) gen_c(v_files []string) string {
-	t0 := time.ticks()
-	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
-	b.parse_imports()
-	t1 := time.ticks()
-	parse_time := t1 - t0
-	b.info('PARSE: ${parse_time}ms')
-	//
-	b.checker.check_files(b.parsed_files)
-	t2 := time.ticks()
-	check_time := t2 - t1
-	b.info('CHECK: ${check_time}ms')
-	if b.checker.nr_errors > 0 {
-		b.print_errors(b.checker.errors)
-		exit(1)
-	}
-	// println('starting cgen...')
-	res := gen.cgen(b.parsed_files, b.table, b.pref)
-	t3 := time.ticks()
-	gen_time := t3 - t2
-	b.info('C GEN: ${gen_time}ms')
-	// println('cgen done')
-	// println(res)
-	return res
-}
-
-pub fn (b mut Builder) build_c(v_files []string, out_file string) {
-	b.out_name_c = out_file
-	b.info('build_c($out_file)')
-	mut f := os.create(out_file) or {
-		panic(err)
-	}
-	f.writeln(b.gen_c(v_files))
-	f.close()
-	// os.write_file(out_file, b.gen_c(v_files))
-}
-
-pub fn (b mut Builder) build_x64(v_files []string, out_file string) {
-	$if !linux {
-		println('v -x64 can only generate Linux binaries for now')
-		println('You are not on a Linux system, so you will not ' + 'be able to run the resulting executable')
-	}
-	t0 := time.ticks()
-	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
-	b.parse_imports()
-	t1 := time.ticks()
-	parse_time := t1 - t0
-	b.info('PARSE: ${parse_time}ms')
-	b.checker.check_files(b.parsed_files)
-	t2 := time.ticks()
-	check_time := t2 - t1
-	b.info('CHECK: ${check_time}ms')
-	x64.gen(b.parsed_files, out_file)
-	t3 := time.ticks()
-	gen_time := t3 - t2
-	b.info('x64 GEN: ${gen_time}ms')
-}
-
 // parse all deps from already parsed files
 pub fn (b mut Builder) parse_imports() {
 	mut done_imports := []string

vlib/v/builder/c.v

@@ -0,0 +1,79 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+)
+
+pub fn (b mut Builder) gen_c(v_files []string) string {
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	//
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	if b.checker.nr_errors > 0 {
+		b.print_errors(b.checker.errors)
+		exit(1)
+	}
+	// println('starting cgen...')
+	// TODO: move gen.cgen() to c.gen()
+	res := gen.cgen(b.parsed_files, b.table, b.pref)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('C GEN: ${gen_time}ms')
+	// println('cgen done')
+	// println(res)
+	return res
+}
+
+pub fn (b mut Builder) build_c(v_files []string, out_file string) {
+	b.out_name_c = out_file
+	b.info('build_c($out_file)')
+	mut f := os.create(out_file) or {
+		panic(err)
+	}
+	f.writeln(b.gen_c(v_files))
+	f.close()
+	// os.write_file(out_file, b.gen_c(v_files))
+}
+
+pub fn (b mut Builder) compile_c(files []string, pref &pref.Preferences) {
+	if os.user_os() != 'windows' && pref.ccompiler == 'msvc' {
+		verror('Cannot build with msvc on ${os.user_os()}')
+	}
+	// cgen.genln('// Generated by V')
+	// println('compile2()')
+	if pref.is_verbose {
+		println('all .v files before:')
+		println(files)
+	}
+	// v1 compiler files
+	// v.add_v_files_to_compile()
+	// v.files << v.dir
+	// v2 compiler
+	// b.set_module_lookup_paths()
+	files << b.get_builtin_files()
+	files << b.get_user_files()
+	b.set_module_lookup_paths()
+	if pref.is_verbose {
+		println('all .v files:')
+		println(files)
+	}
+	mut out_name_c := get_vtmp_filename(pref.out_name, '.tmp.c')
+	if pref.is_so {
+		out_name_c = get_vtmp_filename(pref.out_name, '.tmp.so.c')
+	}
+	b.build_c(files, out_name_c)
+	b.cc()
+}
+
+

vlib/v/builder/compile.v

@@ -35,39 +35,14 @@ pub fn compile(command string, pref &pref.Preferences) {
 	}
 	mut tmark := benchmark.new_benchmark()
 	mut files := []string
-	if pref.backend == .x64 {
+	match pref.backend {
-		// v.files << v.v_files_from_dir(os.join_path(v.pref.vlib_path,'builtin','bare'))
+		.c { b.compile_c(files, pref) }
-		files << pref.path
+		.js { b.compile_js(files, pref) }
-		b.set_module_lookup_paths()
+		.x64 { b.compile_x64(files, pref) }
-		b.build_x64(files, pref.out_name)
+		else {
-	} else {
+			eprintln('backend not implemented `$pref.backend`')
-		if os.user_os() != 'windows' && pref.ccompiler == 'msvc' {
+			exit(1)
-			verror('Cannot build with msvc on ${os.user_os()}')
 		}
-		// cgen.genln('// Generated by V')
-		// println('compile2()')
-		if pref.is_verbose {
-			println('all .v files before:')
-			println(files)
-		}
-		// v1 compiler files
-		// v.add_v_files_to_compile()
-		// v.files << v.dir
-		// v2 compiler
-		// b.set_module_lookup_paths()
-		files << b.get_builtin_files()
-		files << b.get_user_files()
-		b.set_module_lookup_paths()
-		if pref.is_verbose {
-			println('all .v files:')
-			println(files)
-		}
-		mut out_name_c := get_vtmp_filename(pref.out_name, '.tmp.c')
-		if pref.is_so {
-			out_name_c = get_vtmp_filename(pref.out_name, '.tmp.so.c')
-		}
-		b.build_c(files, out_name_c)
-		b.cc()
 	}
 	if pref.is_stats {
 		tmark.stop()

vlib/v/builder/js.v

@@ -0,0 +1,53 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+	v.gen.js
+)
+
+pub fn (b mut Builder) gen_js(v_files []string) string {
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	if b.checker.nr_errors > 0 {
+		exit(1)
+	}
+	res := js.gen(b.parsed_files, b.table, b.pref)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('JS GEN: ${gen_time}ms')
+	return res
+}
+
+pub fn (b mut Builder) build_js(v_files []string, out_file string) {
+	b.out_name_js = out_file
+	b.info('build_js($out_file)')
+	mut f := os.create(out_file) or {
+		panic(err)
+	}
+	f.writeln(b.gen_js(v_files))
+	f.close()
+}
+
+pub fn (b mut Builder) compile_js(files []string, pref &pref.Preferences) {
+	//TODO files << b.get_builtin_files()
+	files << b.get_user_files()
+	b.set_module_lookup_paths()
+	if pref.is_verbose {
+		println('all .v files:')
+		println(files)
+	}
+	b.build_js(files, pref.out_name + '.js')
+	//TODO run the file
+}

vlib/v/builder/x64.v

@@ -0,0 +1,38 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+	v.gen.x64
+)
+
+pub fn (b mut Builder) build_x64(v_files []string, out_file string) {
+	$if !linux {
+		println('v -x64 can only generate Linux binaries for now')
+		println('You are not on a Linux system, so you will not ' + 'be able to run the resulting executable')
+	}
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	x64.gen(b.parsed_files, out_file)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('x64 GEN: ${gen_time}ms')
+}
+
+pub fn (b mut Builder) compile_x64(files []string, pref &pref.Preferences) {
+	// v.files << v.v_files_from_dir(os.join_path(v.pref.vlib_path,'builtin','bare'))
+	files << pref.path
+	b.set_module_lookup_paths()
+	b.build_x64(files, pref.out_name)	
+}

vlib/v/checker/checker.v

@@ -413,7 +413,7 @@ pub fn (c mut Checker) call_fn(call_expr mut ast.CallExpr) table.Type {
 		return table.void_type
 	}
 	call_expr.return_type = f.return_type
-	if f.is_c || call_expr.is_c {
+	if f.is_c || call_expr.is_c || f.is_js || call_expr.is_js {
 		for arg in call_expr.args {
 			c.expr(arg.expr)
 		}
@@ -922,7 +922,7 @@ fn (c mut Checker) stmt(node ast.Stmt) {
 			c.expected_type = table.void_type
 			c.fn_return_type = it.return_type
 			c.stmts(it.stmts)
-			if !it.is_c && !it.no_body && it.return_type != table.void_type && !c.returns &&
+			if !it.is_c && !it.is_js && !it.no_body && it.return_type != table.void_type && !c.returns &&
 				!(it.name in ['panic', 'exit']) {
 				c.error('missing return at end of function `$it.name`', it.pos)
 			}

vlib/v/fmt/fmt.v

@@ -256,7 +256,7 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
 			s := it.str(f.table)
 			// f.write(it.str(f.table))
 			f.write(s.replace(f.cur_mod + '.', ''))			// `Expr` instead of `ast.Expr` in mod ast
-			if !it.is_c {
+			if !it.is_c && !it.is_js {
 				f.writeln(' {')
 				f.stmts(it.stmts)
 				f.writeln('}\n')

vlib/v/gen/js/jsdoc.v

@@ -0,0 +1,87 @@
+module js
+
+import (
+	strings
+	v.ast
+)
+
+struct JsDoc {
+	gen &JsGen
+	mut:
+	out strings.Builder
+	empty_line bool
+}
+
+fn new_jsdoc(gen &JsGen) &JsDoc {
+	return &JsDoc {
+		out: strings.new_builder(20)
+		gen: gen
+	}
+}
+
+fn (d mut JsDoc) gen_indent() {
+	if d.gen.indents[d.gen.namespace] > 0 && d.empty_line {
+		d.out.write(tabs[d.gen.indents[d.gen.namespace]])
+	}
+	d.empty_line = false
+}
+
+fn (d mut JsDoc) write(s string) {
+	d.gen_indent()
+	d.out.write(s)
+}
+
+fn (d mut JsDoc) writeln(s string) {
+	d.gen_indent()
+	d.out.writeln(s)
+	d.empty_line = true
+}
+
+fn (d mut JsDoc) reset() {
+	d.out = strings.new_builder(20)
+	d.empty_line = false
+}
+
+fn (d mut JsDoc) gen_typ(typ string, name string) string {
+	d.reset()
+	d.write('/**')
+	d.write(' @type {$typ}')
+	if name.len > 0 {
+		d.write(' - $name')
+	}
+	d.write(' */')
+	return d.out.str()
+}
+
+fn (d mut JsDoc) gen_ctor(fields []ast.StructField) string {
+	d.reset()
+	d.writeln('/**')
+	d.write('* @param {{')
+	for i, field in fields {
+		d.write('$field.name: ${d.gen.typ(field.typ)}')
+		if i < fields.len-1 { d.write(', ') }
+	}
+	d.writeln('}} values - values for this class fields')
+	d.writeln('* @constructor')
+	d.write('*/')
+	return d.out.str()
+}
+
+fn (d mut JsDoc) gen_fn(it ast.FnDecl) string {
+	d.reset()
+	type_name := d.gen.typ(it.return_type)
+	d.writeln('/**')
+	for i, arg in it.args {
+		if it.is_method && i == 0 { continue }
+		arg_type_name := d.gen.typ(arg.typ)
+		is_varg := i == it.args.len - 1 && it.is_variadic
+		if is_varg {
+			d.writeln('* @param {...$arg_type_name} $arg.name')
+		} else {
+			d.writeln('* @param {$arg_type_name} $arg.name')
+		}
+	}
+	d.writeln('* @return {$type_name}')
+	d.write('*/')
+	return d.out.str()
+}

vlib/v/gen/js/tests/js.js

@@ -0,0 +1,127 @@
+// V_COMMIT_HASH 83289d7
+// V_CURRENT_COMMIT_HASH fc7e64b
+
+// Generated by the V compiler
+"use strict";
+
+const CONSTANTS = Object.freeze({
+	/** @type {number} - i_am_a_const */
+	i_am_a_const: 21214
+});
+
+class Companies {
+	/**
+	* @param {{google: number, amazon: boolean, yahoo: string}} values - values for this class fields
+	* @constructor
+	*/
+	constructor(values) {
+		this.google = values.google
+		this.amazon = values.amazon
+		this.yahoo = values.yahoo
+	}
+	
+	/**
+	* @return {number}
+	*/
+	method() {
+		const it = this;
+		const ss = new Companies({
+			google: 2, 
+			amazon: true, 
+			yahoo: "hello"
+		});
+		/** @type {[number, number]} */
+		const [a, b] = hello(2, "google", "not google");
+		/** @type {string} - glue */
+		const glue = (a > 2 ? "more_glue" : a > 5 ? "more glueee" : "less glue");
+		if (a !== 2) {
+		}
+		
+		return 0;
+	}
+	
+}
+const POSITION = Object.freeze({
+	GO_BACK: 0,
+	DONT_GO_BACK: 1,
+});
+
+/* program entry point */
+(async function() {
+	/** @type {string} - v */
+	const v = "done";
+	{
+		/** @type {string} - _ */
+		const _ = "block";
+	}
+	
+	/** @type {number} - pos */
+	const pos = POSITION.GO_BACK;
+	/** @type {number} - dun */
+	const dun = CONSTANTS.i_am_a_const * 20;
+	for (let i = 0; i < 10; i++) {
+	}
+	
+	for (let i = 0; i < "hello".length; ++i) {
+		let x = "hello"[i];
+	}
+	
+	for (let x = 1; x < 10; ++x) {
+	}
+	
+	/** @type {number[]} - arr */
+	const arr = [1, 2, 3, 4, 5];
+	for (let tmp1 = 0; tmp1 < arr.length; ++tmp1) {
+		let a = arr[tmp1];
+	}
+	
+	/** @type {Map<string, string>} - ma */
+	const ma = new Map([
+		["str", "done"],
+		["ddo", "baba"]
+	]);
+	for (let [m, n] of ma) {
+		/** @type {string} - iss */
+		const iss = m;
+	}
+	
+	await new Promise(function(resolve){
+		async(0, "hello");
+		resolve();
+	});
+	
+})();
+
+
+/**
+* @param {number} num
+* @param {string} def
+* @return {void}
+*/
+function async(num, def) {
+}
+
+
+/* [inline] */
+/**
+* @param {number} game_on
+* @param {...string} dummy
+* @return {multi_return_int_int}
+*/
+function hello(game_on, ...dummy) {
+	for (let tmp2 = 0; tmp2 < dummy.length; ++tmp2) {
+		let dd = dummy[tmp2];
+		/** @type {string} - l */
+		const l = dd;
+	}
+	
+	(function defer() {
+		/** @type {string} - do */
+		const do = "not";
+	})();
+	return [game_on + 2, 221];
+}
+
+
+
+

vlib/v/gen/js/tests/js.v

@@ -0,0 +1,76 @@
+
+const (
+    i_am_a_const = 21214
+)
+
+struct Companies {
+	google int
+    amazon bool
+    yahoo string
+}
+
+enum POSITION {
+    GO_BACK,
+    DONT_GO_BACK
+}
+
+fn main() {
+    v := "done"
+    {
+        _ := "block"
+    }
+
+    pos := POSITION.GO_BACK
+
+    dun := i_am_a_const * 20
+
+    for i := 0; i < 10; i++ {}
+
+    for i, x in 'hello' {}
+
+    for x in 1..10 {}
+
+    arr := [1,2,3,4,5]
+    for a in arr {}
+
+    ma := {
+        'str':  "done"
+        'ddo': "baba"
+    }
+
+    for m, n in ma {
+        iss := m
+    }
+
+    go async(0, "hello")
+}
+
+fn async(num int, def string) {}
+
+[inline]
+fn hello(game_on int, dummy ...string) (int, int) {
+    defer {
+        do := "not"
+    }
+    for dd in dummy {
+        l := dd
+    }
+    return game_on + 2, 221
+}
+
+fn (it Companies) method() int {
+
+    ss := Companies {
+        google: 2
+        amazon: true
+        yahoo: "hello"
+	}
+
+   a, b := hello(2, 'google', 'not google')
+  
+   glue := if a > 2 { 'more_glue' } else if a > 5 {'more glueee'} else { 'less glue' } 
+
+    if a != 2 {}
+
+   return 0
+}

vlib/v/gen/jsgen.v

@@ -1,194 +0,0 @@
-module gen
-
-import (
-	strings
-	v.ast
-	v.table
-	term
-)
-
-struct JsGen {
-	out   strings.Builder
-	table &table.Table
-}
-
-pub fn jsgen(program ast.File, table &table.Table) string {
-	mut g := JsGen{
-		out: strings.new_builder(100)
-		table: table
-	}
-	for stmt in program.stmts {
-		g.stmt(stmt)
-		g.writeln('')
-	}
-	return (g.out.str())
-}
-
-pub fn (g &JsGen) save() {}
-
-pub fn (g mut JsGen) write(s string) {
-	g.out.write(s)
-}
-
-pub fn (g mut JsGen) writeln(s string) {
-	g.out.writeln(s)
-}
-
-fn (g mut JsGen) stmts(stmts []ast.Stmt) {
-	for stmt in stmts {
-		g.stmt(stmt)
-	}
-}
-
-fn (g mut JsGen) stmt(node ast.Stmt) {
-	match node {
-		ast.FnDecl {
-			type_sym := g.table.get_type_symbol(it.return_type)
-			g.write('/** @return { $type_sym.name } **/\nfunction ${it.name}(')
-			for arg in it.args {
-				arg_type_sym := g.table.get_type_symbol(arg.typ)
-				g.write(' /** @type { $arg_type_sym.name } **/ $arg.name')
-			}
-			g.writeln(') { ')
-			for stmt in it.stmts {
-				g.stmt(stmt)
-			}
-			g.writeln('}')
-		}
-		ast.Return {
-			g.write('return ')
-			if it.exprs.len > 0 {}
-			else {
-				g.expr(it.exprs[0])
-			}
-			g.writeln(';')
-		}
-		ast.AssignStmt {
-			if it.left.len > it.right.len {}
-			// TODO: multi return
-			else {
-				for i, ident in it.left {
-					var_info := ident.var_info()
-					var_type_sym := g.table.get_type_symbol(var_info.typ)
-					val := it.right[i]
-					g.write('var /* $var_type_sym.name */ $ident.name = ')
-					g.expr(val)
-					g.writeln(';')
-				}
-			}
-		}
-		ast.ForStmt {
-			g.write('while (')
-			g.expr(it.cond)
-			g.writeln(') {')
-			for stmt in it.stmts {
-				g.stmt(stmt)
-			}
-			g.writeln('}')
-		}
-		ast.StructDecl {
-			// g.writeln('typedef struct {')
-			// for field in it.fields {
-			// g.writeln('\t$field.ti.name $field.name;')
-			// }
-			g.writeln('var $it.name = function() {};')
-		}
-		ast.ExprStmt {
-			g.expr(it.expr)
-		}
-		/*
-			match it.expr {
-				// no ; after an if expression
-				ast.IfExpr {}
-				else {
-					g.writeln(';')
-				}
-	}
-	*/
-
-		else {
-			verror('jsgen.stmt(): bad node')
-		}
-	}
-}
-
-fn (g mut JsGen) expr(node ast.Expr) {
-	// println('cgen expr()')
-	match node {
-		ast.IntegerLiteral {
-			g.write(it.val)
-		}
-		ast.FloatLiteral {
-			g.write(it.val)
-		}
-		/*
-		ast.UnaryExpr {
-			g.expr(it.left)
-			g.write(' $it.op ')
-		}
-		*/
-
-		ast.StringLiteral {
-			g.write('tos3("$it.val")')
-		}
-		ast.InfixExpr {
-			g.expr(it.left)
-			g.write(' $it.op.str() ')
-			g.expr(it.right)
-		}
-		// `user := User{name: 'Bob'}`
-		ast.StructInit {
-			type_sym := g.table.get_type_symbol(it.typ)
-			g.writeln('/*$type_sym.name*/{')
-			for i, field in it.fields {
-				g.write('\t$field : ')
-				g.expr(it.exprs[i])
-				g.writeln(', ')
-			}
-			g.write('}')
-		}
-		ast.CallExpr {
-			g.write('${it.name}(')
-			for i, arg in it.args {
-				g.expr(arg.expr)
-				if i != it.args.len - 1 {
-					g.write(', ')
-				}
-			}
-			g.write(')')
-		}
-		ast.Ident {
-			g.write('$it.name')
-		}
-		ast.BoolLiteral {
-			if it.val == true {
-				g.write('true')
-			}
-			else {
-				g.write('false')
-			}
-		}
-		ast.IfExpr {
-			for i, branch in it.branches {
-				if i == 0 {
-					g.write('if (')
-					g.expr(branch.cond)
-					g.writeln(') {')
-				}
-				else if i < it.branches.len-1 || !it.has_else {
-					g.write('else if (')
-					g.expr(branch.cond)
-					g.writeln(') {')
-				}
-				else {
-					g.write('else {')
-				}
-				g.stmts(branch.stmts)
-				g.writeln('}')
-			}
-		}
-		else {
-			println(term.red('jsgen.expr(): bad node'))
-		}
-	}
-}

vlib/v/parser/fn.v

@@ -8,12 +8,14 @@ import v.table
 import v.scanner
 import v.token
 
-pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
+pub fn (p mut Parser) call_expr(is_c bool, is_js bool, mod string) ast.CallExpr {
 	first_pos := p.tok.position()
 	tok := p.tok
 	name := p.check_name()
 	fn_name := if is_c {
 		'C.$name'
+	} else if is_js {
+		'JS.$name'
 	} else if mod.len > 0 {
 		'${mod}.$name'
 	} else {
@@ -51,6 +53,7 @@ pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
 		mod: p.mod
 		pos: pos
 		is_c: is_c
+		is_js: is_js
 		or_block: ast.OrExpr{
 			stmts: or_stmts
 			is_used: is_or_block_used
@@ -89,9 +92,10 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		p.next()
 	}
 	p.check(.key_fn)
-	// C.
+	// C. || JS.
 	is_c := p.tok.kind == .name && p.tok.lit == 'C'
-	if is_c {
+	is_js := p.tok.kind == .name && p.tok.lit == 'JS'
+	if is_c || is_js {
 		p.next()
 		p.check(.dot)
 	}
@@ -133,7 +137,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 	if p.tok.kind == .name {
 		// TODO high order fn
 		name = p.check_name()
-		if !is_c && !p.pref.translated && scanner.contains_capital(name) {
+		if !is_js && !is_c && !p.pref.translated && scanner.contains_capital(name) {
 			p.error('function names cannot contain uppercase letters, use snake_case instead')
 		}
 		if is_method && p.table.get_type_symbol(rec_type).has_method(name) {
@@ -179,6 +183,8 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 	} else {
 		if is_c {
 			name = 'C.$name'
+		} else if is_js {
+			name = 'JS.$name'
 		} else {
 			name = p.prepend_mod(name)
 		}
@@ -191,6 +197,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 			return_type: return_type
 			is_variadic: is_variadic
 			is_c: is_c
+			is_js: is_js
 			is_generic: is_generic
 		})
 	}
@@ -217,6 +224,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		is_method: is_method
 		rec_mut: rec_mut
 		is_c: is_c
+		is_js: is_js
 		no_body: no_body
 		pos: pos
 		is_builtin: p.builtin_mod || p.mod in ['math', 'strconv', 'strconv.ftoa', 'hash.wyhash',

vlib/v/parser/parse_type.v

@@ -109,11 +109,12 @@ pub fn (p mut Parser) parse_type() table.Type {
 		p.next()
 	}
 	is_c := p.tok.lit == 'C'
-	if is_c {
+	is_js := p.tok.lit == 'JS'
+	if is_c || is_js {
 		p.next()
 		p.check(.dot)
 	}
-	mut typ := p.parse_any_type(is_c, nr_muls > 0)
+	mut typ := p.parse_any_type(is_c, is_js, nr_muls > 0)
 	if is_optional {
 		typ = table.type_set(typ, .optional)
 	}
@@ -123,11 +124,14 @@ pub fn (p mut Parser) parse_type() table.Type {
 	return typ
 }
 
-pub fn (p mut Parser) parse_any_type(is_c, is_ptr bool) table.Type {
+pub fn (p mut Parser) parse_any_type(is_c bool, is_js bool, is_ptr bool) table.Type {
 	mut name := p.tok.lit
 	if is_c {
 		name = 'C.$name'
 	}
+	else if is_js {
+		name = 'JS.$name'
+	}
 	// `module.Type`
 	else if p.peek_tok.kind == .dot {
 		// /if !(p.tok.lit in p.table.imports) {

vlib/v/parser/parser.v

@@ -21,6 +21,7 @@ mut:
 	peek_tok          token.Token
 	table             &table.Table
 	is_c              bool
+	is_js			  bool
 	inside_if         bool
 	inside_for        bool
 	inside_fn         bool
@@ -545,7 +546,7 @@ pub fn (p &Parser) warn_with_pos(s string, pos token.Position) {
 	eprintln(ferror)
 }
 
-pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
+pub fn (p mut Parser) parse_ident(is_c, is_js bool) ast.Ident {
 	// p.warn('name ')
 	pos := p.tok.position()
 	var name := p.check_name()
@@ -563,6 +564,7 @@ pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
 		kind: .unresolved
 		name: name
 		is_c: is_c
+		is_js: is_js
 		mod: p.mod
 		pos: pos
 	}
@@ -618,6 +620,7 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
 pub fn (p mut Parser) name_expr() ast.Expr {
 	var node := ast.Expr{}
 	is_c := p.tok.lit == 'C'
+	is_js := p.tok.lit == 'JS'
 	var mod := ''
 	// p.warn('resetting')
 	p.expr_mod = ''
@@ -629,16 +632,18 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		}
 	}
 	// Raw string (`s := r'hello \n ')
-	if p.tok.lit in ['r', 'c'] && p.peek_tok.kind == .string {
+	if p.tok.lit in ['r', 'c', 'js'] && p.peek_tok.kind == .string {
 		// QTODO
 		// && p.prev_tok.kind != .str_dollar {
 		return p.string_expr()
 	}
 	known_var := p.scope.known_var(p.tok.lit)
-	if p.peek_tok.kind == .dot && !known_var && (is_c || p.known_import(p.tok.lit) || p.mod.all_after('.') ==
+	if p.peek_tok.kind == .dot && !known_var && (is_c || is_js || p.known_import(p.tok.lit) || p.mod.all_after('.') ==
 		p.tok.lit) {
 		if is_c {
 			mod = 'C'
+		} else if is_js {
+			mod = 'JS'
 		} else {
 			// prepend the full import
 			mod = p.imports[p.tok.lit]
@@ -688,10 +693,10 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		} else {
 			// fn call
 			// println('calling $p.tok.lit')
-			x := p.call_expr(is_c, mod)			// TODO `node,typ :=` should work
+			x := p.call_expr(is_c, is_js, mod)			// TODO `node,typ :=` should work
 			node = x
 		}
-	} else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || (p.builtin_mod &&
+	} else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || is_js || (p.builtin_mod &&
 		p.tok.lit in table.builtin_type_names)) && !p.inside_match && !p.inside_match_case && !p.inside_if &&
 		!p.inside_for {
 		// (p.tok.lit.len in [1, 2] || !p.tok.lit[p.tok.lit.len - 1].is_capital()) &&
@@ -718,7 +723,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		}
 	} else {
 		var ident := ast.Ident{}
-		ident = p.parse_ident(is_c)
+		ident = p.parse_ident(is_c, is_js)
 		node = ident
 	}
 	p.expr_mod = ''
@@ -1549,13 +1554,14 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 		p.check(.key_union)
 	}
 	is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot
+	is_js := p.tok.lit == 'JS' && p.peek_tok.kind == .dot
 	if is_c {
-		p.next()		// C
+		p.next()		// C || JS
 		p.next()		// .
 	}
 	is_typedef := p.attr == 'typedef'
 	no_body := p.peek_tok.kind != .lcbr
-	if !is_c && no_body {
+	if !is_c && !is_js && no_body {
 		p.error('`$p.tok.lit` lacks body')
 	}
 	var name := p.check_name()
@@ -1644,6 +1650,8 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 	}
 	if is_c {
 		name = 'C.$name'
+	} else if is_js {
+		name = 'JS.$name'
 	} else {
 		name = p.prepend_mod(name)
 	}
@@ -1677,6 +1685,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 		pub_pos: pub_pos
 		pub_mut_pos: pub_mut_pos
 		is_c: is_c
+		is_js: is_js
 		is_union: is_union
 	}
 }
@@ -1743,7 +1752,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
 		if is_static {
 			p.check(.key_static)
 		}
-		var ident := p.parse_ident(false)
+		var ident := p.parse_ident(false, false)
 		ident.is_mut = is_mut
 		ident.info = ast.IdentVar{
 			is_mut: is_mut

vlib/v/table/table.v

@@ -25,6 +25,7 @@ pub:
 	return_type Type
 	is_variadic bool
 	is_c        bool
+	is_js		bool
 	is_generic  bool
 }
 

vlib/v/tests/in_expression_test.v

@@ -17,12 +17,10 @@ fn test_in_expression() {
 	assert a == true
 	a = false && 0 in arr3
 	assert a == false
-
 	a = true && 0 in arr1
 	assert a == false
 	a = true && 3 in arr1
 	assert a == false
-
 	a = true && !(2 in arr2)
 	assert a == false
 	a = true && !(3 in arr2)
@@ -90,7 +88,6 @@ fn test_in_expression_with_string() {
 	assert a == false
 	a = true && 'abc' in arr1
 	assert a == false
-
 	a = true && !('bc' in arr2)
 	assert a == false
 	a = true && !('abc' in arr2)
@@ -118,12 +115,10 @@ fn test_optimized_in_expression() {
 	assert a == true
 	a = false && 0 in [1, 0]
 	assert a == false
-
 	a = true && 0 in [1, 2]
 	assert a == false
 	a = true && 3 in [1, 2]
 	assert a == false
-
 	a = true && !(2 in [0, 2])
 	assert a == false
 	a = true && !(3 in [0, 2])
@@ -151,12 +146,10 @@ fn test_optimized_in_expression_with_enum() {
 	assert a == true
 	a = false && Colors.red in [.green, .red]
 	assert a == false
-
 	a = true && Colors.red in [.green, .blue]
 	assert a == false
 	a = true && Colors.yellow in [.green, .blue]
 	assert a == false
-
 	a = true && !(Colors.blue in [.red, .blue])
 	assert a == false
 	a = true && !(Colors.yellow in [.red, .blue])
@@ -184,12 +177,10 @@ fn test_optimized_in_expression_with_string() {
 	assert a == true
 	a = false && '' in ['ab', '']
 	assert a == false
-
 	a = true && '' in ['ab', 'bc']
 	assert a == false
 	a = true && 'abc' in ['ab', 'bc']
 	assert a == false
-
 	a = true && !('bc' in ['', 'bc'])
 	assert a == false
 	a = true && !('abc' in ['', 'bc'])