vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

jsgen: implement js backend

pull/4422/head
Abdullah Atta 2020-04-16 02:16:49 +05:00 committed by GitHub
parent a3ab5df2ed
commit 6a186e8f11
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 1592 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/tools/vfmt.v
View File

@ -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)

7
cmd/v/v.v
View File

@ -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 {

5
vlib/v/ast/ast.v
View File

@ -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

3
vlib/v/ast/str.v
View File

@ -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

60
vlib/v/builder/builder.v
View File

@ -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

79
vlib/v/builder/c.v 100644
View File

@ -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()
}

39
vlib/v/builder/compile.v
View File

@ -35,39 +35,14 @@ pub fn compile(command string, pref &pref.Preferences) {
}
mut tmark := benchmark.new_benchmark()
mut files := []string
if pref.backend == .x64 {
// 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)
} else {
if os.user_os() != 'windows' && pref.ccompiler == 'msvc' {
verror('Cannot build with msvc on ${os.user_os()}')
match pref.backend {
.c { b.compile_c(files, pref) }
.js { b.compile_js(files, pref) }
.x64 { b.compile_x64(files, pref) }
else {
eprintln('backend not implemented `$pref.backend`')
exit(1)
}
// 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()

53
vlib/v/builder/js.v 100644
View File

@ -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
}

38
vlib/v/builder/x64.v 100644
View File

@ -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)
}

4
vlib/v/checker/checker.v
View File

@ -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)
}

2
vlib/v/fmt/fmt.v
View File

@ -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')

1064
vlib/v/gen/js/js.v 100644
View File

File diff suppressed because it is too large Load Diff

87
vlib/v/gen/js/jsdoc.v 100644
View File

@ -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()
}

127
vlib/v/gen/js/tests/js.js 100644
View File

@ -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];
}

76
vlib/v/gen/js/tests/js.v 100644
View File

@ -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
}

194
vlib/v/gen/jsgen.v
View File

@ -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'))
}
}
}

16
vlib/v/parser/fn.v
View File

@ -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',

10
vlib/v/parser/parse_type.v
View File

@ -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) {

27
vlib/v/parser/parser.v
View File

@ -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

1
vlib/v/table/table.v
View File

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

9
vlib/v/tests/in_expression_test.v
View File

@ -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'])