class Error < NotImplementedError

def initialize(message, ast)

if ast.loc

message += ' at ' + ast.loc.expression.source_buffer.name.to_s

message += ':' + ast.loc.expression.line.inspect

message += ':' + ast.loc.expression.column.to_s

end

super(message)

end

end

class Converter < Serializer

attr_accessor :ast

LOGICAL = :and, :not, :or

OPERATORS = [:[], :[]=], [:not, :!], [:**], [:*, :/, :%], [:+, :-],

[:>>, :<<], [:&], [:^, :|], [:<=, :<, :>, :>=],

[:==, :!=, :===, :"!==", :=~, :!~], [:and, :or]

INVERT_OP = {

:< => :>=,

:<= => :>,

:== => :!=,

:!= => :==,

:> => :<=,

:>= => :<,

:=== => :'!=='

}

GROUP_OPERATORS = [:begin, :dstr, :dsym, :and, :or, :casgn, :if]

VASGN = [:cvasgn, :ivasgn, :gvasgn, :lvasgn]

attr_accessor :binding, :ivars, :namespace

def initialize( ast, comments, vars = {} )

super()

@ast, @comments, @vars = ast, comments, vars.dup

@varstack = []

@scope = ast

@inner = nil

@rbstack = []

@next_token = :return

@handlers = {}

@@handlers.each do |name|

@handlers[name] = method("on_#{name}")

end

@state = nil

@block_this = nil

@block_depth = nil

@prop = nil

@instance_method = nil

@prototype = nil

@class_parent = nil

@class_name = nil

@jsx = false

@autobind = true

@eslevel = :es5

@strict = false

@comparison = :equality

@or = :logical

@underscored_private = true

@redoable = false

end

def width=(width)

@width = width

end

def convert

scope @ast

if @strict

if @sep == '; '

@lines.first.unshift "\"use strict\"#@sep"

else

@lines.unshift Line.new('"use strict";')

end

end

end

def operator_index op

OPERATORS.index( OPERATORS.find{ |el| el.include? op } ) || -1

end

# define a new scope; primarily determines what variables are visible and deals with hoisting of

# declarations

def scope( ast, args=nil )

scope, @scope = @scope, ast

inner, @inner = @inner, nil

mark = output_location

@varstack.push @vars

@vars = args if args

@vars = Hash[@vars.map {|key, value| [key, true]}]

parse( ast, :statement )

# retroactively add a declaration for 'pending' variables

vars = @vars.select {|key, value| value == :pending}.keys

unless vars.empty?

insert mark, "#{es2015 ? 'let' : 'var'} #{vars.join(', ')}#{@sep}"

vars.each {|var| @vars[var] = true}

end

ensure

@vars = @varstack.pop

@scope = scope

@inner = inner

end

# handle the oddity where javascript considers there to be a scope (e.g. the body of an if statement),

# whereas Ruby does not.

def jscope( ast, args=nil )

@varstack.push @vars

@vars = args if args

@vars = Hash[@vars.map {|key, value| [key, true]}]

parse( ast, :statement )

ensure

pending = @vars.select {|key, value| value == :pending}

@vars = @varstack.pop

@vars.merge! pending

end

def s(type, *args)

Parser::AST::Node.new(type, args)

end

attr_accessor :strict, :eslevel, :module_type, :comparison, :or, :underscored_private

def es2015

@eslevel >= 2015

end

def es2016

@eslevel >= 2016

end

def es2017

@eslevel >= 2017

end

def es2018

@eslevel >= 2018

end

def es2019

@eslevel >= 2019

end

def es2020

@eslevel >= 2020

end

def es2021

@eslevel >= 2021

end

def es2022

@eslevel >= 2022

end

@@handlers = []

def self.handle(*types, &block)

types.each do |type|

define_method("on_#{type}", block)

@@handlers << type

end

end

# extract comments that either precede or are included in the node.

# remove from the list this node may appear later in the tree.

def comments(ast)

if ast.loc and ast.loc.respond_to? :expression

expression = ast.loc.expression

list = @comments[ast].select do |comment|

expression.source_buffer == comment.loc.expression.source_buffer and

comment.loc.expression.begin_pos < expression.end_pos

end

else

list = @comments[ast]

end

@comments[ast] -= list

list.map do |comment|

if comment.text.start_with? '=begin'

if comment.text.include? '*/'

comment.text.sub(/\A=begin/, '').sub(/^=end\Z/, '').gsub(/^/, '//')

else

comment.text.sub(/\A=begin/, '/*').sub(/^=end\Z/, '*/')

end

else

comment.text.sub(/^#/, '//') + "\n"

end

end

end

def parse(ast, state=:expression)

oldstate, @state = @state, state

oldast, @ast = @ast, ast

return unless ast

handler = @handlers[ast.type]

unless handler

raise Error.new("unknown AST type #{ ast.type }", ast)

end

if state == :statement and not @comments[ast].empty?

comments(ast).each {|comment| puts comment.chomp}

end

handler.call(*ast.children)

ensure

@ast = oldast

@state = oldstate

end

def parse_all(*args)

@options = (Hash === args.last) ? args.pop : {}

sep = @options[:join].to_s

state = @options[:state] || :expression

index = 0

args.each do |arg|

put sep unless index == 0

parse arg, state

index += 1 unless arg == s(:begin)

end

end

def group( ast )

if [:dstr, :dsym].include? ast.type and es2015

parse ast

else

put '('; parse ast; put ')'

end

end

def redoable(block)

save_redoable = @redoable

has_redo = proc do |node|

node.children.any? do |child|

next false unless child.is_a? Parser::AST::Node

next true if child.type == :redo

next false if %i[for while while_post until until_post].include? child.type

has_redo[child]

end

end

@redoable = has_redo[@ast]

if @redoable

put es2015 ? 'let ' : 'var '

put "redo$#@sep"

puts 'do {'

put "redo$ = false#@sep"

scope block

put "#@nl} while(redo$)"

else

scope block

end

ensure

@redoable = save_redoable

end

def timestamp(file)

super

return unless file

walk = proc do |ast|

if ast.loc and ast.loc.expression

filename = ast.loc.expression.source_buffer.name

if filename and not filename.empty?

@timestamps[filename] ||= File.mtime(filename) rescue nil

end

end

ast.children.each do |child|

walk[child] if child.is_a? Parser::AST::Node

end

end

walk[@ast] if @ast

end

end

module AST

class Node

def is_method?

return false if type == :attr

return true if type == :call

return true unless loc

if loc.respond_to? :selector

return true if children.length > 2

selector = loc.selector

elsif type == :defs

return true if children[1] =~ /[!?]$/

return true if children[2].children.length > 0

selector = loc.name

elsif type == :def

return true if children[0] =~ /[!?]$/

return true if children[1].children.length > 0

selector = loc.name

end

return true unless selector and selector.source_buffer

selector.source_buffer.source[selector.end_pos] == '('

end

end

end