通过核心Erlang将Erlang编译成Javascript

Question

所以开始在LuvvieScript上取得进展然后在推特上一切都开始了.https://twitter.com/gordonguthrie/status/389659700741943296

Anthony Ramine https://twitter.com/nokusu指出我做错了，我应该通过核心Erlang而不是Erlang从Erlang编译到JavaScript。对我来说，这是一个很有吸引力的选择.Twitter不是讨论的合适媒介，我想我应该在这里写下来，并获得一些关于这个问题的建议。

战略概览

LuvvieScript有三个核心需求：

• Erlang的一个有效子集，编译成相同的、具有表现性的Javascript
• 完整的源映射，以便可以在浏览器中在LuvvieScript而不是Javascript中调试
• 一个“运行时”客户端javascript环境(带有服务器端通信)在(一种页面内监控器.)中执行LuvvieScript模块。

这些方案中的第三个方案有点超出了这场辩论的范围，但前两个方案是核心。

有一个惰性的--gits的必然结果--我想尽可能多地使用Erlang和Javascript语法工具(词汇、解析器、标记器、AST转换等等)，并编写尽可能少的代码。

当前思维

代码当前的编写方式如下：

• 将代码编译到Erlang (其中有行号)
• 标记代码(保留注释和空格)，并使用这些标记构建将行/列信息映射到标记的字典。
• 将字典和AST合并，给出一行/col AST (有一些关于对不同位置的fns进行分组)
• 将这个新的Erlang转换为Javascript，这是在SpiderMonkey Parser API中实现的。
• 使用Javascript (如brushtail )在Javascript https://github.com/puffnfresh/brushtail中对尾调用进行变异
• 使用像ESCodeGen这样的Javascript实用程序来发出javascript https://github.com/Constellation/escodegen

基本上，我得到了一个Erlang，它看起来像这样：

 [{function,
      {19,{1,9}},
      atom1_fn,0,
      [{clause,
           {19,none},
           [],
           [[]],
           [{match,
                {20,none},
                [{var,{20,{5,6}},'D'}],
                [{atom,{20,{11,15}},blue}]},
            {var,{21,{5,6}},'D'}]}]}]},

然后，我将其转换为Javascript JSON AST，如下所示：

{
    "type": "Program",
    "body": [
        {
            "type": "VariableDeclaration",
            "declarations": [
                {
                    "type": "VariableDeclarator",
                    "id": {
                        "type": "Identifier",
                        "name": "answer",
                        "loc": {
                            "start": {
                                "line": 2,
                                "column": 4
                            },
                            "end": {
                                "line": 2,
                                "column": 10
                            }
                        }
                    },
                    "init": {
                        "type": "BinaryExpression",
                        "operator": "*",
                        "left": {
                            "type": "Literal",
                            "value": 6,
                            "raw": "6",
                            "loc": {
                                "start": {
                                    "line": 2,
                                    "column": 13
                                },
                                "end": {
                                    "line": 2,
                                    "column": 14
                                }
                            }
                        },
                        "right": {
                            "type": "Literal",
                            "value": 7,
                            "raw": "7",
                            "loc": {
                                "start": {
                                    "line": 2,
                                    "column": 17
                                },
                                "end": {
                                    "line": 2,
                                    "column": 18
                                }
                            }
                        },
                        "loc": {
                            "start": {
                                "line": 2,
                                "column": 13
                            },
                            "end": {
                                "line": 2,
                                "column": 18
                            }
                        }
                    },
                    "loc": {
                        "start": {
                            "line": 2,
                            "column": 4
                        },
                        "end": {
                            "line": 2,
                            "column": 18
                        }
                    }
                }
            ],
            "kind": "var",
            "loc": {
                "start": {
                    "line": 2,
                    "column": 0
                },
                "end": {
                    "line": 2,
                    "column": 19
                }
            }
        }
    ],
    "loc": {
        "start": {
            "line": 2,
            "column": 0
          },
        "end": {
            "line": 2,
            "column": 19
           }
    }
}

艾尔问题

Anthony的观点做得很好-- Core Erlang是一种比Erlang更简单、更规则的语言，应该比普通Erlang更容易转换到Javascript，但它不是很好的文档。

我可以很容易地获得核心Erlang的AST类表示：

{c_module,[],
    {c_literal,[],basic_types},
    [{c_var,[],{atom1_fn,0}},
     {c_var,[],{atom2_fn,0}},
     {c_var,[],{bish_fn,1}},
     {c_var,[],{boolean_fn,0}},
     {c_var,[],{float_fn,0}},
     {c_var,[],{int_fn,0}},
     {c_var,[],{module_info,0}},
     {c_var,[],{module_info,1}},
     {c_var,[],{string_fn,0}}],
    [],
    [{{c_var,[],{int_fn,0}},{c_fun,[],[],{c_literal,[],1}}},
     {{c_var,[],{float_fn,0}},{c_fun,[],[],{c_literal,[],2.3}}},
     {{c_var,[],{boolean_fn,0}},{c_fun,[],[],{c_literal,[],true}}},
     {{c_var,[],{atom1_fn,0}},{c_fun,[],[],{c_literal,[],blue}}},
     {{c_var,[],{atom2_fn,0}},{c_fun,[],[],{c_literal,[],'Blue 4 U'}}},
     {{c_var,[],{string_fn,0}},{c_fun,[],[],{c_literal,[],"string theory"}}},
     {{c_var,[],{bish_fn,1}},
      {c_fun,[],
          [{c_var,[],'_cor0'}],
          {c_case,[],
              {c_var,[],'_cor0'},
              [{c_clause,[],
                   [{c_literal,[],bash}],
                   {c_literal,[],true},
                   {c_literal,[],berk}},
               {c_clause,[],
                   [{c_literal,[],bosh}],
                   {c_literal,[],true},
                   {c_literal,[],bork}},
               {c_clause,
                   [compiler_generated],
                       [{c_var,[],'_cor1'}],
                   {c_literal,[],true},
                   {c_primop,[],
                       {c_literal,[],match_fail},
                       [{c_tuple,[],
                            [{c_literal,[],case_clause},
                             {c_var,[],'_cor1'}]}]}}]}}},
     {{c_var,[],{module_info,0}},
      {c_fun,[],[],
          {c_call,[],
              {c_literal,[],erlang},
              {c_literal,[],get_module_info},
              [{c_literal,[],basic_types}]}}},
     {{c_var,[],{module_info,1}},
      {c_fun,[],
          [{c_var,[],'_cor0'}],
          {c_call,[],
              {c_literal,[],erlang},
              {c_literal,[],get_module_info},
              [{c_literal,[],basic_types},{c_var,[],'_cor0'}]}}}]}

但没有直线。所以我可以得到一个能够生成JS的AST，但关键的是不能生成SourceMaps。

问题1如何获得所需的行信息-(我已经可以从“普通”Erlang令牌获得列信息.)

在生产过程中，Erlang与普通的Erlang稍有不同，因为它开始在函数调用中替换变量名来代替它自己的内部名称，这也会导致一些Source问题。一个例子是Erlang子句：

bish_fn(A) ->
    case A of
        bash -> berk;
        bosh -> bork
    end.

Erlang AST很好地保存了这些名称：

 [{function,
      {31,{1,8}},
      bish_fn,1,
      [{clause,
           {31,none},
           [{var,{31,{11,12}},'A'}],
           [[]],
           [{'case',
                {32,none},
                [{var,{32,{11,12}},'A'}],
                [{clause,
                     {33,none},
                     [{atom,{33,{9,13}},bash}],
                     [[]],
                     [{atom,{34,{13,17}},berk}]},
                 {clause,
                     {35,none},
                     [{atom,{35,{9,13}},bosh}],
                     [[]],
                     [{atom,{36,{13,17}},bork}]}]}]}]}]},

核心Erlang已经删除了函数中调用的参数的名称：

'bish_fn'/1 =
    %% Line 30
    fun (_cor0) ->
    %% Line 31
    case _cor0 of
      %% Line 32
      <'bash'> when 'true' ->
          'berk'
      %% Line 33
      <'bosh'> when 'true' ->
          'bork'
      ( <_cor1> when 'true' ->
        primop 'match_fail'
            ({'case_clause',_cor1})
        -| ['compiler_generated'] )
    end

问题2，，是否有什么可以保留或映射核心Erlang中的变量名称？

问题3我理解核心Erlang是明确的，它的目的是使易于编译成 Erlang，并编写修改Erlang代码的工具--但是问题是，它真的会使编译out的Erlang变得更容易吗？

选项

我可以分叉核心erlang代码并添加一个源映射选项，但是我在这里播放Lazy 卡.

更新

作为对Eric的回应，我应该澄清我是如何生成核心Erlang cerl记录的。我首先使用以下方法将普通的Erlang编译为核心erlang：

c(some_module, to_core)

然后我在这个函数中使用core_scan和core_parse，这个函数是从compiler.erl中提取的。

compile(File) ->
    case file:read_file(File) of
        {ok,Bin} ->
            case core_scan:string(binary_to_list(Bin)) of
                {ok,Toks,_} ->
                    case core_parse:parse(Toks) of
                        {ok, Mod} ->
                            {ok, Mod};
                        {error,E} ->
                            {error, {parse, E}}
                    end;
                {error,E,_} ->
                    {error, {scan, E}}
            end;
        {error,E} ->
            {error,{read, E}}
    end.

问题是如何使工具链发出带注释的AST。我想我需要自己加上这些选项：

Answer 1

1. 行号作为注释提供。如果您查看cerl模块(我建议您使用这个模块)，您将看到所有内容都包含一个注释列表。其中一个注释是表示行号的朴素数字。如果我对Core的直接记忆是正确的，并且atom1_fn变量位于第10行，那么AST应该如下所示： {c_var,10，{atom1_fn,0}}

1. 不，你得自己做簿记。外面没有什么可以为你做的。

1. 我不太明白这个问题。

安东尼说的关于核心二郎的一切都是真的。这些都是我选择核心Erlang作为Joxa的目标语言的原因。我从中吸取的教训是，尽管Core是一个很好的、易于瞄准的目标语言，但它有两个主要的缺点，它们都不适合它。

1. Dialyzer只在光束文件的抽象代码块中使用Erlang。在编译到compiling时，无法将这样的AST放到抽象代码块中。所以如果你的目标是核心Erlang，Dialyzer不适合你。无论是否生成正确的规范属性，这都是正确的。

1. 您将无法使用在Erlang上工作的工具。例如，编译到Erlang的能力。到/从源代码编译器的核心Erlang非常错误，根本无法工作。这是在许多实际应用领域取得的重大胜利。

由于上述原因，我实际上正在将Joxa重定向到Erlang。

顺便说一句，你可能对这个项目感兴趣。https://github.com/5HT/shen。它是一个已经存在并正在工作的Erlang的JavaScript编译器。虽然我在这方面没有太多经验。

** Edit:您实际上可以看到从erlang源生成的核心Erlang。在学习如何编译到核心时，这会有很大帮助。ec_compile在erlware_commons回购中有很多实用函数可以帮助实现这一点。