Remove all files, redirect to GitHub.HEADmaster

1 files changed, 0 insertions, 629 deletions

diff --git a/tests/examplefiles/example.moon b/tests/examplefiles/example.moon
deleted file mode 100644
index d4415e32..00000000
--- a/tests/examplefiles/example.moon
+++ /dev/null
@@ -1,629 +0,0 @@
--- transform.moon
--- Leaf Corcoran (leafot@gmail.com) 2011
---
--- This is part of the MoonScript compiler. See <http://moonscript.org>
--- MoonScript is licensed under the MIT License
---
-
-module "moonscript.transform", package.seeall
-
-types = require "moonscript.types"
-util = require "moonscript.util"
-data = require "moonscript.data"
-
-import reversed from util
-import ntype, build, smart_node, is_slice from types
-import insert from table
-
-export Statement, Value, NameProxy, LocalName, Run
-
--- always declares as local
-class LocalName
-  new: (@name) => self[1] = "temp_name"
-  get_name: => @name
-
-class NameProxy
-  new: (@prefix) =>
-    self[1] = "temp_name"
-
-  get_name: (scope) =>
-    if not @name
-      @name = scope\free_name @prefix, true
-    @name
-
-  chain: (...) =>
-    items = {...} -- todo: fix ... propagation
-    items = for i in *items
-      if type(i) == "string"
-        {"dot", i}
-      else
-        i
-
-    build.chain {
-      base: self
-      unpack items
-    }
-
-  index: (key) =>
-    build.chain {
-      base: self, {"index", key}
-    }
-
-  __tostring: =>
-    if @name
-      ("name<%s>")\format @name
-    else
-      ("name<prefix(%s)>")\format @prefix
-
-class Run
-  new: (@fn) =>
-    self[1] = "run"
-
-  call: (state) =>
-    self.fn state
-
--- transform the last stm is a list of stms
--- will puke on group
-apply_to_last = (stms, fn) ->
-  -- find last (real) exp
-  last_exp_id = 0
-  for i = #stms, 1, -1
-    stm = stms[i]
-    if stm and util.moon.type(stm) != Run
-      last_exp_id = i
-      break
-
-  return for i, stm in ipairs stms
-    if i == last_exp_id
-      fn stm
-    else
-      stm
-
--- is a body a sindle expression/statement
-is_singular = (body) ->
-  return false if #body != 1
-  if "group" == ntype body
-    is_singular body[2]
-  else
-    true
-
-constructor_name = "new"
-
-class Transformer
-  new: (@transformers, @scope) =>
-    @seen_nodes = {}
-
-  transform: (scope, node, ...) =>
-    -- print scope, node, ...
-    return node if @seen_nodes[node]
-    @seen_nodes[node] = true
-    while true
-      transformer = @transformers[ntype node]
-      res = if transformer
-        transformer(scope, node, ...) or node
-      else
-        node
-      return node if res == node
-      node = res
-
-  __call: (node, ...) =>
-    @transform @scope, node, ...
-
-  instance: (scope) =>
-    Transformer @transformers, scope
-
-  can_transform: (node) =>
-    @transformers[ntype node] != nil
-
-construct_comprehension = (inner, clauses) ->
-  current_stms = inner
-  for _, clause in reversed clauses
-    t = clause[1]
-    current_stms = if t == "for"
-      _, names, iter = unpack clause
-      {"foreach", names, iter, current_stms}
-    elseif t == "when"
-      _, cond = unpack clause
-      {"if", cond, current_stms}
-    else
-      error "Unknown comprehension clause: "..t
-    current_stms = {current_stms}
-
-  current_stms[1]
-
-Statement = Transformer {
-  assign: (node) =>
-    _, names, values = unpack node
-    -- bubble cascading assigns
-    if #values == 1 and types.cascading[ntype values[1]]
-      values[1] = @transform.statement values[1], (stm) ->
-        t = ntype stm
-        if types.is_value stm
-          {"assign", names, {stm}}
-        else
-          stm
-
-      build.group {
-        {"declare", names}
-        values[1]
-      }
-    else
-      node
-
-  export: (node) =>
-    -- assign values if they are included
-    if #node > 2
-      if node[2] == "class"
-        cls = smart_node node[3]
-        build.group {
-          {"export", {cls.name}}
-          cls
-        }
-      else
-        build.group {
-          node
-          build.assign {
-            names: node[2]
-            values: node[3]
-          }
-        }
-    else
-      nil
-
-  update: (node) =>
-    _, name, op, exp = unpack node
-    op_final = op\match "^(.+)=$"
-    error "Unknown op: "..op if not op_final
-    build.assign_one name, {"exp", name, op_final, exp}
-
-  import: (node) =>
-    _, names, source = unpack node
-
-    stubs = for name in *names
-      if type(name) == "table"
-        name
-      else
-        {"dot", name}
-
-    real_names = for name in *names
-      type(name) == "table" and name[2] or name
-
-    if type(source) == "string"
-      build.assign {
-        names: real_names
-        values: [build.chain { base: source, stub} for stub in *stubs]
-      }
-    else
-      source_name = NameProxy "table"
-      build.group {
-        {"declare", real_names}
-        build["do"] {
-          build.assign_one source_name, source
-          build.assign {
-            names: real_names
-            values: [build.chain { base: source_name, stub} for stub in *stubs]
-          }
-        }
-      }
-
-  comprehension: (node, action) =>
-    _, exp, clauses = unpack node
-
-    action = action or (exp) -> {exp}
-    construct_comprehension action(exp), clauses
-
-  -- handle cascading return decorator
-  if: (node, ret) =>
-    if ret
-      smart_node node
-      -- mutate all the bodies
-      node['then'] = apply_to_last node['then'], ret
-      for i = 4, #node
-        case = node[i]
-        body_idx = #node[i]
-        case[body_idx] = apply_to_last case[body_idx], ret
-    node
-
-  with: (node, ret) =>
-    _, exp, block = unpack node
-    scope_name = NameProxy "with"
-    build["do"] {
-      build.assign_one scope_name, exp
-      Run => @set "scope_var", scope_name
-      build.group block
-      if ret
-        ret scope_name
-    }
-
-  foreach: (node) =>
-    smart_node node
-    if ntype(node.iter) == "unpack"
-      list = node.iter[2]
-
-      index_name = NameProxy "index"
-      list_name = NameProxy "list"
-
-      slice_var = nil
-      bounds = if is_slice list
-        slice = list[#list]
-        table.remove list
-        table.remove slice, 1
-
-        slice[2] = if slice[2] and slice[2] != ""
-          max_tmp_name = NameProxy "max"
-          slice_var = build.assign_one max_tmp_name, slice[2]
-          {"exp", max_tmp_name, "<", 0
-            "and", {"length", list_name}, "+", max_tmp_name
-            "or", max_tmp_name }
-        else
-          {"length", list_name}
-
-        slice
-      else
-        {1, {"length", list_name}}
-
-      build.group {
-        build.assign_one list_name, list
-        slice_var
-        build["for"] {
-          name: index_name
-          bounds: bounds
-          body: {
-            {"assign", node.names, {list_name\index index_name}}
-            build.group node.body
-          }
-        }
-      }
-
-  switch: (node, ret) =>
-    _, exp, conds = unpack node
-    exp_name = NameProxy "exp"
-
-    -- convert switch conds into if statment conds
-    convert_cond = (cond) ->
-      t, case_exp, body = unpack cond
-      out = {}
-      insert out, t == "case" and "elseif" or "else"
-      if  t != "else"
-        insert out, {"exp", case_exp, "==", exp_name} if t != "else"
-      else
-        body = case_exp
-
-      if ret
-        body = apply_to_last body, ret
-
-      insert out, body
-
-      out
-
-    first = true
-    if_stm = {"if"}
-    for cond in *conds
-      if_cond = convert_cond cond
-      if first
-        first = false
-        insert if_stm, if_cond[2]
-        insert if_stm, if_cond[3]
-      else
-        insert if_stm, if_cond
-
-    build.group {
-      build.assign_one exp_name, exp
-      if_stm
-    }
-
-  class: (node) =>
-    _, name, parent_val, body = unpack node
-
-    -- split apart properties and statements
-    statements = {}
-    properties = {}
-    for item in *body
-      switch item[1]
-        when "stm"
-          insert statements, item[2]
-        when "props"
-          for tuple in *item[2,]
-            insert properties, tuple
-
-    -- find constructor
-    constructor = nil
-    properties = for tuple in *properties
-      if tuple[1] == constructor_name
-        constructor = tuple[2]
-        nil
-      else
-        tuple
-
-    parent_cls_name = NameProxy "parent"
-    base_name = NameProxy "base"
-    self_name = NameProxy "self"
-    cls_name = NameProxy "class"
-
-    if not constructor
-      constructor = build.fndef {
-        args: {{"..."}}
-        arrow: "fat"
-        body: {
-          build["if"] {
-            cond: parent_cls_name
-            then: {
-              build.chain { base: "super", {"call", {"..."}} }
-            }
-          }
-        }
-      }
-    else
-      smart_node constructor
-      constructor.arrow = "fat"
-
-    cls = build.table {
-      {"__init", constructor}
-      {"__base", base_name}
-      {"__name", {"string", '"', name}} -- "quote the string"
-      {"__parent", parent_cls_name}
-    }
-
-    -- look up a name in the class object
-    class_lookup = build["if"] {
-      cond: {"exp", "val", "==", "nil", "and", parent_cls_name}
-      then: {
-        parent_cls_name\index"name"
-      }
-    }
-    insert class_lookup, {"else", {"val"}}
-
-    cls_mt = build.table {
-      {"__index", build.fndef {
-        args: {{"cls"}, {"name"}}
-        body: {
-          build.assign_one LocalName"val", build.chain {
-            base: "rawget", {"call", {base_name, "name"}}
-          }
-          class_lookup
-        }
-      }}
-      {"__call", build.fndef {
-        args: {{"cls"}, {"..."}}
-        body: {
-          build.assign_one self_name, build.chain {
-            base: "setmetatable"
-            {"call", {"{}", base_name}}
-          }
-          build.chain {
-            base: "cls.__init"
-            {"call", {self_name, "..."}}
-          }
-          self_name
-        }
-      }}
-    }
-
-    cls = build.chain {
-      base: "setmetatable"
-      {"call", {cls, cls_mt}}
-    }
-
-    value = nil
-    with build
-      value = .block_exp {
-        Run =>
-          @set "super", (block, chain) ->
-            if chain
-              slice = [item for item in *chain[3,]]
-              new_chain = {"chain", parent_cls_name}
-
-              head = slice[1]
-
-              if head == nil
-                return parent_cls_name
-
-              switch head[1]
-                -- calling super, inject calling name and self into chain
-                when "call"
-                  calling_name = block\get"current_block"
-                  slice[1] = {"call", {"self", unpack head[2]}}
-                  act = if ntype(calling_name) != "value" then "index" else "dot"
-                  insert new_chain, {act, calling_name}
-
-                -- colon call on super, replace class with self as first arg
-                when "colon"
-                  call = head[3]
-                  insert new_chain, {"dot", head[2]}
-                  slice[1] = { "call", { "self", unpack call[2] } }
-
-              insert new_chain, item for item in *slice
-
-              new_chain
-            else
-              parent_cls_name
-
-        .assign_one parent_cls_name, parent_val == "" and "nil" or parent_val
-        .assign_one base_name, {"table", properties}
-        .assign_one base_name\chain"__index", base_name
-
-        build["if"] {
-          cond: parent_cls_name
-          then: {
-            .chain {
-              base: "setmetatable"
-              {"call", {
-                base_name,
-                .chain { base: parent_cls_name,  {"dot", "__base"}}
-              }}
-            }
-          }
-        }
-
-        .assign_one cls_name, cls
-        .assign_one base_name\chain"__class", cls_name
-
-        .group if #statements > 0 {
-          .assign_one LocalName"self", cls_name
-          .group statements
-        } else {}
-
-        cls_name
-      }
-
-      value = .group {
-        .declare names: {name}
-        .assign {
-          names: {name}
-          values: {value}
-        }
-      }
-
-    value
-}
-
-class Accumulator
-  body_idx: { for: 4, while: 3, foreach: 4 }
-
-  new: =>
-    @accum_name = NameProxy "accum"
-    @value_name = NameProxy "value"
-    @len_name = NameProxy "len"
-
-  -- wraps node and mutates body
-  convert: (node) =>
-    index = @body_idx[ntype node]
-    node[index] = @mutate_body node[index]
-    @wrap node
-
-  -- wrap the node into a block_exp
-  wrap: (node) =>
-    build.block_exp {
-      build.assign_one @accum_name, build.table!
-      build.assign_one @len_name, 0
-      node
-      @accum_name
-    }
-
-  -- mutates the body of a loop construct to save last value into accumulator
-  -- can optionally skip nil results
-  mutate_body: (body, skip_nil=true) =>
-    val = if not skip_nil and is_singular body
-      with body[1]
-        body = {}
-    else
-      body = apply_to_last body, (n) ->
-        build.assign_one @value_name, n
-      @value_name
-
-    update = {
-      {"update", @len_name, "+=", 1}
-      build.assign_one @accum_name\index(@len_name), val
-    }
-
-    if skip_nil
-      table.insert body, build["if"] {
-        cond: {"exp", @value_name, "!=", "nil"}
-        then: update
-      }
-    else
-      table.insert body, build.group update
-
-    body
-
-default_accumulator = (node) =>
-  Accumulator!\convert node
-
-
-implicitly_return = (scope) ->
-  fn = (stm) ->
-    t = ntype stm
-    if types.manual_return[t] or not types.is_value stm
-      stm
-    elseif types.cascading[t]
-      scope.transform.statement stm, fn
-    else
-      if t == "comprehension" and not types.comprehension_has_value stm
-        stm
-      else
-        {"return", stm}
-
-  fn
-
-Value = Transformer {
-  for: default_accumulator
-  while: default_accumulator
-  foreach: default_accumulator
-
-  comprehension: (node) =>
-    a = Accumulator!
-    node = @transform.statement node, (exp) ->
-      a\mutate_body {exp}, false
-    a\wrap node
-
-  tblcomprehension: (node) =>
-    _, key_exp, value_exp, clauses = unpack node
-
-    accum = NameProxy "tbl"
-    dest = build.chain { base: accum, {"index", key_exp} }
-    inner = build.assign_one dest, value_exp
-
-    build.block_exp {
-      build.assign_one accum, build.table!
-      construct_comprehension {inner}, clauses
-      accum
-    }
-
-  fndef: (node) =>
-    smart_node node
-    node.body = apply_to_last node.body, implicitly_return self
-    node
-
-  if: (node) => build.block_exp { node }
-  with: (node) => build.block_exp { node }
-  switch: (node) =>
-    build.block_exp { node }
-
-  -- pull out colon chain
-  chain: (node) =>
-    stub = node[#node]
-    if type(stub) == "table" and stub[1] == "colon_stub"
-      table.remove node, #node
-
-      base_name = NameProxy "base"
-      fn_name = NameProxy "fn"
-
-      is_super = node[2] == "super"
-      @transform.value build.block_exp {
-        build.assign {
-          names: {base_name}
-          values: {node}
-        }
-
-        build.assign {
-          names: {fn_name}
-          values: {
-            build.chain { base: base_name, {"dot", stub[2]} }
-          }
-        }
-
-        build.fndef {
-          args: {{"..."}}
-          body: {
-            build.chain {
-              base: fn_name, {"call", {is_super and "self" or base_name, "..."}}
-            }
-          }
-        }
-      }
-
-  block_exp: (node) =>
-    _, body = unpack node
-
-    fn = nil
-    arg_list = {}
-
-    insert body, Run =>
-      if @has_varargs
-        insert arg_list, "..."
-        insert fn.args, {"..."}
-
-    fn = smart_node build.fndef body: body
-    build.chain { base: {"parens", fn}, {"call", arg_list} }
-}
-