furnace-avm2 0.9.0 → 0.9.1

data/lib/furnace-avm2/source/declaration_tokens/callee_token.rb

@@ -6,11 +6,13 @@ module Furnace::AVM2::Tokens
       super(origin, [
         *header,
         *declaration(origin, options),
-        (Furnace::AVM2::Decompiler.new(@body, options).decompile if @body),
-        Furnace::Code::NewlineToken.new(origin, options)
+        (Furnace::AVM2::Decompiler.new(@body,
+                options).decompile if @body),
+        (Furnace::Code::NewlineToken.new(origin,
+                options) if @body && !options[:closure])
       ], options)
 
-      if options[:debug_funids]
+      if options[:debug_funids] && !options[:closure]
         @children.unshift \
           CommentToken.new(origin,
             "Function ##{options[:index]}",
@@ -53,14 +55,15 @@ module Furnace::AVM2::Tokens
 
       if @method.needs_rest?
         args << ArgumentDeclarationToken.new(origin, [
-          RestArgumentToken.new(origin, "rest", options)
+          RestArgumentToken.new(origin, "local0", options)
         ], options)
       end
 
       tokens = []
 
       tokens << ArgumentsToken.new(origin, args, options)
-      if @method.return_type
+
+      if @method.return_type && !options[:closure]
         tokens << TypeToken.new(origin, [
           MultinameToken.new(origin, @method.return_type, options)
         ], options)

data/lib/furnace-avm2/source/declaration_tokens/class_implementations_token.rb

@@ -7,7 +7,11 @@ module Furnace::AVM2::Tokens
     end
 
     def text_before
-      "implements "
+      if @options[:environment] == :interface
+        "extends "
+      else
+        "implements "
+      end
     end
 
     def text_between

data/lib/furnace-avm2/source/declaration_tokens/class_specifiers_token.rb

@@ -3,9 +3,10 @@ require_relative 'specifiers_token'
 module Furnace::AVM2::Tokens
   class ClassSpecifiersToken < SpecifiersToken
     def specifiers
-      list = super
+      list = []
       list << "final"   if @origin.final?
       list << "dynamic" unless @origin.sealed?
+      list << "public"
       list
     end
   end

data/lib/furnace-avm2/source/declaration_tokens/class_token.rb

@@ -3,7 +3,11 @@ module Furnace::AVM2::Tokens
     include TokenWithTraits
 
     def initialize(origin, options={})
-      options = options.merge(environment: :class)
+      if origin.interface?
+        options = options.merge(environment: :interface)
+      else
+        options = options.merge(environment: :class)
+      end
 
       super(origin, [
         ClassSpecifiersToken.new(origin, options),

data/lib/furnace-avm2/source/declaration_tokens/metadata_token.rb

@@ -0,0 +1,25 @@
+module Furnace::AVM2::Tokens
+  class MetadataToken < Furnace::Code::TerminalToken
+    def initialize(origin, options={})
+      super(origin, options)
+    end
+
+    def to_text
+      if @origin.metadata?
+        elements = []
+
+        @origin.metadata.each do |datum|
+          values = datum.to_hash.map do |key, value|
+            %Q[#{key || '*'}="#{value}"]
+          end
+
+          elements << "#{datum.name}(#{values.join(",")})"
+        end
+
+        "[#{elements.join(",")}]\n"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/furnace-avm2/source/declaration_tokens/method_specifiers_token.rb

@@ -3,10 +3,11 @@ require_relative 'specifiers_token'
 module Furnace::AVM2::Tokens
   class MethodSpecifiersToken < SpecifiersToken
     def specifiers
-      list = []
+      list, super_list = [], super
       list << "final"    if @origin.final? && !@options[:static]
-      list << "override" if @origin.override?
-      list.concat super
+      list << "override" if @origin.override? && !super_list.include?("private")
+      list.concat super_list
+      list << "native"   if @origin.body.nil? && @options[:environment] != :interface
       list
     end
   end

data/lib/furnace-avm2/source/declaration_tokens/method_token.rb

@@ -4,6 +4,7 @@ module Furnace::AVM2::Tokens
   class MethodToken < CalleeToken
     def initialize(origin, options={})
       super(origin, [
+        MetadataToken.new(origin, options),
         MethodSpecifiersToken.new(origin, options),
         FunctionNameToken.new(origin, [
           MultinameToken.new(origin, origin.name, options.merge(omit_ns: true))

data/lib/furnace-avm2/source/declaration_tokens/multiname_token.rb

@@ -6,32 +6,47 @@ module Furnace::AVM2::Tokens
     end
 
     def to_text
-      if @multiname
+      name_to_text(@multiname)
+    end
+
+    protected
+
+    def name_to_text(multiname)
+      if multiname
         if @options[:debug_names]
-          debug = "/* #{@multiname.to_astlet.to_sexp} */ "
+          debug = "/* #{multiname.to_astlet.to_sexp} */ "
         end
 
-        qualified_name = ->(ns) {
-          if @options[:ns].include?(ns) || ["*", ""].include?(ns.name.to_s) || @options[:omit_ns]
-            "#{debug}#{@multiname.name}"
+        qualified_name = ->(ns, name) {
+          if @options[:ns].include?(ns) ||
+                ["*", ""].include?(ns.name) ||
+                @options[:omit_ns]
+            "#{debug}#{name}"
           else
-            "#{debug}#{ns.name}.#{@multiname.name}"
+            "#{debug}#{ns.name}.#{name}"
           end
         }
 
-        case @multiname.kind
+        case multiname.kind
         when :QName, :QNameA
-          qualified_name.(@multiname.ns)
+          qualified_name.(multiname.ns, multiname.name)
         when :GenericName
-          "#{debug}#{@multiname.name.name}.<#{@multiname.parameters.map(&:name).join}>"
+          parameters = multiname.parameters.map do |param|
+            subname = name_to_text(param)
+            # Fuck you.
+            subname = "#{subname} " if subname.end_with? ">"
+            subname
+          end
+          "#{debug}#{multiname.name.name}.<#{parameters.join(", ")}>"
         when :Multiname
-          if @multiname.ns_set.ns.count == 1
-            qualified_name.(@multiname.ns_set.ns[0])
+          if multiname.ns_set.ns.count == 1
+            qualified_name.(multiname.ns_set.ns[0], multiname.name)
           else
-            "#{debug}%%Multiname"
+            "/* #{multiname.to_astlet.to_sexp} */ " +
+                qualified_name.(multiname.ns_set.ns[0], multiname.name)
           end
         else
-          "#{debug}%%#{@multiname.kind}"
+          "#{debug}%%#{multiname.kind}"
         end
       else
         "%%nil"

data/lib/furnace-avm2/source/declaration_tokens/package_token.rb

@@ -1,15 +1,15 @@
 module Furnace::AVM2::Tokens
   class PackageToken < Furnace::Code::NonterminalToken
     def initialize(origin, options={})
-      options[:ns] = options[:ns].uniq.reject { |ns|
+      options[:ns] = options[:ns].reject { |ns|
         ns.name == "" || ns.name == "*"
       }
 
-      import_ns = options[:ns]
-
-      if options[:package_name]
-        options[:ns] = (options[:ns] + [ options[:package_name].ns ]).uniq
-      end
+      import_ns = options[:ns].reject { |ns|
+        ns.name == options[:package_name].ns.name ||
+          ns.name == "__AS3__.vec" ||
+          ns.name !~ /^[A-Za-z0-9_$.]+$/
+      }
 
       super(origin, [
         (PackageNameToken.new(origin, options[:package_name].ns.name, options) if options[:package_name]),
@@ -19,8 +19,9 @@ module Furnace::AVM2::Tokens
           },
           (Furnace::Code::NewlineToken.new(origin, options) if import_ns.any?),
           (case options[:package_type]
-           when :class;  ClassToken.new(origin, options)
-           when :script; ScriptToken.new(origin, options)
+           when :class;     ClassToken.new(origin, options)
+           when :interface; ClassToken.new(origin, options)
+           when :script;    ScriptToken.new(origin, options)
            end)
         ], options)
       ], options)

data/lib/furnace-avm2/source/declaration_tokens/scope_token.rb

@@ -11,6 +11,8 @@ module Furnace::AVM2::Tokens
     def text_after
       if @options[:continuation]
         "} "
+      elsif @options[:closure]
+        "}"
       else
         "}\n"
       end

data/lib/furnace-avm2/source/declaration_tokens/script_token.rb

@@ -5,9 +5,12 @@ module Furnace::AVM2::Tokens
     def initialize(origin, options={})
       options = options.merge(environment: :script)
 
+      global_code = Furnace::AVM2::Decompiler.new(origin.initializer_body,
+              options.merge(global_code: true)).decompile
+
       super(origin, [
         *transform_traits(origin, options.merge(static: false)),
-        Furnace::AVM2::Decompiler.new(origin.initializer_body, options).decompile
+        (global_code if global_code.children.any?)
       ], options)
     end
   end

data/lib/furnace-avm2/source/declaration_tokens/slot_token.rb

@@ -2,6 +2,7 @@ module Furnace::AVM2::Tokens
   class SlotToken < Furnace::Code::SurroundedToken
     def initialize(origin, options={})
       super(origin, [
+        MetadataToken.new(origin, options),
         SpecifiersToken.new(origin, options),
         SlotNameToken.new(origin, options),
         (TypeToken.new(origin, [

data/lib/furnace-avm2/source/declaration_tokens/specifiers_token.rb

@@ -4,15 +4,17 @@ module Furnace::AVM2::Tokens
       list = []
       list << "static" if @options[:static]
 
-      if @origin.name.ns.name == ""
-        list << "public"
-      elsif @options[:instance]
-        if @options[:instance].protected_ns? &&
-              # protected_ns is not singleton. Why? Fuck me if I know.
-              @origin.name.ns.name == @options[:instance].protected_ns.name
-          list << "protected"
-        elsif @origin.name.ns != @options[:instance].name.ns
-          list << "private"
+      unless @options[:environment] == :interface
+        if @origin.name.ns.name == ""
+          list << "public"
+        elsif @options[:instance]
+          if @options[:instance].protected_ns? &&
+                # protected_ns is not singleton. Why? Fuck me if I know.
+                @origin.name.ns.name == @options[:instance].protected_ns.name
+            list << "protected"
+          elsif @origin.name.ns != @options[:instance].name.ns
+            list << "private"
+          end
         end
       end
 

data/lib/furnace-avm2/source/decompiler.rb

@@ -13,17 +13,65 @@ module Furnace::AVM2
     end
 
     def initialize(body, options)
-      @body, @method, @options = body, body.method, options
+      @body, @method, @options = body, body.method, options.dup
+      @closure = @options.delete(:closure)
+    end
+
+    ActivationPrologue = Matcher.new do
+      [:begin,
+        [:push_scope,
+          [:get_local, 0]],
+        [:set_local, -1,
+          [:new_activation]],
+        [:set_local, capture(:activation_local),
+          [:get_local, -1]],
+        [:push_scope,
+          [:get_local, -1]],
+        skip
+      ]
+    end
+
+    RegularPrologue = Matcher.new do
+      [:begin,
+        [:push_scope,
+          [:get_local, 0]],
+        skip
+      ]
     end
 
     def decompile
       begin
         @locals = Set.new([0]) + (1..@method.param_count).to_a
+        @scopes = []
 
         @nf = @body.code_to_nf
 
-        stmt_block @nf, function: true
+        if captures = ActivationPrologue.match(@nf)
+          @closure_slots = {}
+          @body.slot_traits.each do |trait|
+            @closure_slots[trait.idx] = trait
+          end
+
+          @closure_locals = Set.new
+
+          @nf.children.slice! 0...4
+        else
+          if RegularPrologue.match @nf
+            @nf.children.slice! 0...1
+          else
+            # No prologue; probably a closure.
+          end
+        end
+
+        @global_slots = @options[:global_slots]
+
+        stmt_block @nf,
+          function: !@options[:global_code],
+          closure:  @closure
+
       rescue Exception => e
+        @failed = true
+
         comment = "'Ouch!' cried I, then died.\n" +
           "#{e.class}: #{e.message}\n" +
           "#{e.backtrace[0..5].map { |l| "    #{l}\n"}.join}" +
@@ -31,103 +79,144 @@ module Furnace::AVM2
 
         token(ScopeToken, [
           token(CommentToken, comment)
-        ], function: true)
+        ], function: !@options[:global_code],
+           closure:  @closure)
+
+      ensure
+        if stat = @options[:stat]
+          stat[:total] += 1
+
+          if @failed
+            stat[:failed]  += 1
+          elsif @partial
+            stat[:partial] += 1
+          else
+            stat[:success] += 1
+          end
+        end
       end
     end
 
     # Statements
 
-    Prologue = Matcher.new do
-      [:push_scope,
-        [:get_local, 0]]
-    end
-
     def stmt_block(block, options={})
       nodes = []
 
       block.children.each do |opcode|
-        if (opcode.type == :push_scope && Prologue.match(opcode))
-          # Ignore these
-          next
+        if respond_to?(:"stmt_#{opcode.type}")
+          send :"stmt_#{opcode.type}", opcode, nodes
+        else
+          catch(:skip) do
+            nodes << token(StatementToken, [
+              handle_expression(opcode)
+            ])
+          end
         end
+      end
 
-        case opcode.type
-        when :if
-          condition, if_true, if_false = opcode.children
+    rescue ExpressionNotRecognized => e
+      @partial = true
 
-          nodes << token(IfToken, handle_expression(condition),
-            stmt_block(if_true, continuation: !if_false.nil?))
-          nodes << token(ElseToken,
-            stmt_block(if_false)) if if_false
+      comment = "Well, this is embarassing.\n\n" +
+        "Expression recognizer failed at:\n" +
+        "#{e.opcode.inspect}\n"
 
-        when :label
-          name, = opcode.children
+      if e.context != e.opcode
+        comment << "\nOpcode at the top of stack:\n" +
+          "#{e.context.inspect}\n"
+      end
 
-          nodes << token(LabelDeclarationToken, name)
+      nodes << CommentToken.new(@body, comment, @options)
 
-        when :while
-          condition, body = opcode.children
+    ensure
+      if $!.nil? || $!.is_a?(ExpressionNotRecognized)
+        return token(ScopeToken, nodes, options)
+      end
+    end
 
-          nodes << token(WhileToken, handle_expression(condition),
-            stmt_block(body))
+    def stmt_if(opcode, nodes)
+      condition, if_true, if_false = opcode.children
 
-        when :for_in, :for_each_in
-          value_reg, value_type, object_reg, body = opcode.children
+      nodes << token(IfToken, handle_expression(condition),
+        stmt_block(if_true, continuation: !if_false.nil?))
+      nodes << token(ElseToken,
+        stmt_block(if_false)) if if_false
+    end
 
-          @locals.add(value_reg)
+    def stmt_label(opcode, nodes)
+      name, = opcode.children
 
-          if opcode.type == :for_in
-            klass = ForToken
-          elsif opcode.type == :for_each_in
-            klass = ForEachToken
-          end
+      nodes << token(LabelDeclarationToken, name)
+    end
 
-          nodes << token(klass,
-            token(InToken, [
-              token(LocalVariableToken, [
-                token(VariableNameToken, local_name(value_reg)),
-                type_token(value_type)
-              ]),
-              token(VariableNameToken, local_name(object_reg)),
-            ]),
-            stmt_block(body))
+    def stmt_while(opcode, nodes)
+      condition, body = opcode.children
 
-        when :break
-          nodes << token(ReturnToken, exprs(opcode.children))
+      nodes << token(WhileToken, handle_expression(condition),
+        stmt_block(body))
+    end
 
-        when :continue
-          nodes << token(ContinueToken, exprs(opcode.children))
+    def stmt_for(opcode, nodes)
+      value_reg, value_type, object_reg, body = opcode.children
 
-        when :throw
-          nodes << token(ThrowToken, exprs(opcode.children))
+      @locals.add(value_reg)
 
-        when :return_value, :return_void
-          nodes << token(ReturnToken, exprs(opcode.children))
+      if opcode.type == :for_in
+        klass = ForToken
+      elsif opcode.type == :for_each_in
+        klass = ForEachToken
+      end
 
-        else
-          node = handle_expression(opcode)
-          node = token(StatementToken, [node])
-          nodes << node
-        end
+      if @closure_slots
+        name = token(VariableNameToken, @closure_slots[value_reg].name.name)
+      else
+        name = token(VariableNameToken, local_name(value_reg))
       end
 
-    rescue ExpressionNotRecognized => e
-      comment = "Well, this is embarassing.\n\n" +
-        "Expression recognizer failed at:\n" +
-        "#{e.opcode.inspect}\n"
+      nodes << token(klass,
+        token(InToken, [
+          token(LocalVariableToken, [
+            name,
+            type_token(value_type)
+          ]),
+          token(VariableNameToken, local_name(object_reg)),
+        ]),
+        stmt_block(body))
+    end
+    alias :stmt_for_in      :stmt_for
+    alias :stmt_for_each_in :stmt_for
 
-      if e.context != e.opcode
-        comment << "\nOpcode at the top of stack:\n" +
-          "#{e.context.inspect}\n"
-      end
+    def stmt_break(opcode, nodes)
+      nodes << token(ReturnToken, exprs(opcode.children))
+    end
 
-      nodes << CommentToken.new(@body, comment, @options)
+    def stmt_continue(opcode, nodes)
+      nodes << token(ContinueToken, exprs(opcode.children))
+    end
 
-    ensure
-      if $!.nil? || $!.is_a?(ExpressionNotRecognized)
-        return token(ScopeToken, nodes,
-          continuation: options[:continuation],
-          function:     options[:function])
+    def stmt_throw(opcode, nodes)
+      nodes << token(ThrowToken, exprs(opcode.children))
+    end
+
+    def stmt_return(opcode, nodes)
+      nodes << token(ReturnToken, exprs(opcode.children))
+    end
+    alias :stmt_return_value :stmt_return
+    alias :stmt_return_void  :stmt_return
+
+    def stmt_push_scope(opcode, nodes)
+      if @options[:global_code]
+        @scopes.push opcode.children.first
+      else
+        raise "pushscope in nonglobal code"
+      end
+    end
+
+    def stmt_pop_scope(opcode, nodes)
+      if @options[:global_code]
+        @scopes.pop
+      else
+        raise "popscope in nonglobal code"
       end
     end
 
@@ -202,7 +291,11 @@ module Furnace::AVM2
       if index < 0
         "sp#{-index}"
       elsif index == 0
-        "this"
+        if @options[:static]
+          @options[:instance].name.name
+        else
+          "this"
+        end
       elsif index <= @method.param_count
         if @method.has_param_names?
           @method.param_names[index - 1]
@@ -219,6 +312,38 @@ module Furnace::AVM2
       token(VariableNameToken, local_name(index))
     end
 
+    ActivationGetSlot = Matcher.new do
+      [:get_slot,
+        capture(:index),
+        [:get_scope_object, 1]]
+    end
+
+    GlobalGetSlot = Matcher.new do
+      [:get_slot,
+        capture(:index),
+        either[
+          [:get_global_scope],    # normalized form
+          [:get_scope_object, 0]  # not emitted by ASC
+        ]]
+    end
+
+    def expr_get_slot(opcode)
+      if @closure_slots && captures = ActivationGetSlot.match(opcode)
+        # treat as a local variable
+        slot = @closure_slots[captures[:index]]
+        token(VariableNameToken, slot.name.name)
+      elsif captures = GlobalGetSlot.match(opcode)
+        # treat as a global property
+        if @global_slots
+          slot = @global_slots[captures[:index]]
+          get_name(nil, slot.name.to_astlet)
+        else
+          token(PropertyNameToken,
+            "$__GLOBAL_#{captures[:index]}")
+        end
+      end
+    end
+
     IMMEDIATE_TYPE_MAP = {
       :any       => '*',
       :integer   => 'int',
@@ -243,42 +368,94 @@ module Furnace::AVM2
       end
     end
 
-    def expr_set_var(name, value, declare)
-      if IMMEDIATE_TYPE_MAP.include?(value.type)
-        inside = value
-        type   = token(TypeToken, [
-          token(ImmediateTypenameToken, IMMEDIATE_TYPE_MAP[value.type])
-        ])
-      elsif value.type == :coerce || value.type == :convert
-        inside_type, inside = value.children
-        type = type_token(inside_type)
-      else
-        inside = value
-        type   = nil
-      end
+    XmlLiteralPreMatcher = Matcher.new do
+      [:coerce, [:q, "XML"], any]
+    end
 
+    def expr_set_var(name, value, type, declare)
       if declare
         token(LocalVariableToken, [
           token(VariableNameToken, name),
           type,
           token(InitializationToken, [
-            expr(inside)
+            expr(value)
           ])
         ])
       else
         token(AssignmentToken, [
           token(VariableNameToken, name),
-          expr(inside)
+          expr(value)
         ])
       end
     end
 
     def expr_set_local(opcode)
       index, value = opcode.children
+      if IMMEDIATE_TYPE_MAP.include?(value.type)
+        type = token(TypeToken, [
+          token(ImmediateTypenameToken, IMMEDIATE_TYPE_MAP[value.type])
+        ])
+      elsif XmlLiteralPreMatcher.match value
+        # XML literals work through expr_coerce
+        type  = type_token(value.children.first)
+        value = value
+      elsif value.type == :coerce || value.type == :convert
+        # Don't emit spurious coercion; typed variables already
+        # imply it
+        type  = type_token(value.children.first)
+        value = value.children.last
+      end
 
-      expr_set_var(local_name(index), value, !@locals.include?(index))
+      expr_set_var(local_name(index), value, type, !@locals.include?(index))
     ensure
-      @locals << index
+      @locals.add index if index
+    end
+
+    ActivationSetSlot = Matcher.new do
+      [:set_slot,
+        capture(:index),
+        [:get_scope_object, 1],
+        capture(:value)]
+    end
+
+    GlobalSetSlot = Matcher.new do
+      [:set_slot,
+        capture(:index),
+        either[
+          [:get_global_scope],    # normalized form
+          [:get_scope_object, 0]  # not emitted by ASC
+        ],
+        capture(:value)]
+    end
+
+    def expr_set_slot(opcode)
+      if @closure_slots && captures = ActivationSetSlot.match(opcode)
+        # treat as a local variable
+        index, value = captures.values_at(:index, :value)
+        slot = @closure_slots[index]
+
+        type = type_token(slot.type.to_astlet) if slot.type
+        expr = expr_set_var(slot.name.name, value, type,
+              !@closure_locals.include?(index))
+        @closure_locals.add index
+
+        expr
+      elsif captures = GlobalSetSlot.match(opcode)
+        # treat as a global property
+        index, value = captures.values_at(:index, :value)
+
+        if @global_slots
+          slot = @global_slots[index]
+          name = get_name(nil, slot.name.to_astlet)
+        else
+          token(PropertyNameToken, "$__GLOBAL_#{index}")
+        end
+
+        token(AssignmentToken, [
+          name,
+          expr(value)
+        ])
+      end
     end
 
     ## Arithmetics
@@ -416,9 +593,22 @@ module Furnace::AVM2
 
     PropertyGlobal = Matcher.new do
       [any,
-        [either[:find_property, :find_property_strict],
-          capture(:multiname)],
-        backref(:multiname),
+        either_multi[
+          [
+            [ either[:find_property, :find_property_strict],
+                  capture(:multiname)],
+            backref(:multiname),
+          ],
+          [
+            [:find_property_strict,
+              [:m, [:set, "*"], any]],
+            capture(:multiname)
+          ],
+          [
+            [:get_scope_object, 0],
+            capture(:multiname)
+          ],
+        ],
         capture_rest(:arguments)]
     end
 
@@ -438,9 +628,16 @@ module Furnace::AVM2
 
     def expr_get_super(opcode)
       subject, multiname, = opcode.children
-      if This.match subject
-        get_name(token(SuperToken), multiname)
+
+      stmt = get_name(token(SuperToken), multiname)
+
+      unless This.match subject
+        stmt = token(SupplementaryCommentToken,
+          "subject != this: #{subject.inspect}",
+          [ stmt ])
       end
+
+      stmt
     end
 
     def expr_set_property(opcode)
@@ -461,12 +658,19 @@ module Furnace::AVM2
 
     def expr_set_super(opcode)
       subject, multiname, value = opcode.children
-      if This.match subject
-        token(AssignmentToken, [
-          get_name(token(SuperToken), multiname),
-          expr(value)
-        ])
+
+      stmt = token(AssignmentToken, [
+        get_name(token(SuperToken), multiname),
+        expr(value)
+      ])
+
+      unless This.match subject
+        stmt = token(SupplementaryCommentToken,
+          "subject != this: #{subject.inspect}",
+          [ stmt ])
       end
+
+      stmt
     end
 
     def expr_delete_property(opcode)
@@ -492,6 +696,7 @@ module Furnace::AVM2
     def expr_call_property(opcode)
       expr_do_property(opcode, CallToken)
     end
+    alias :expr_call_property_lex :expr_call_property
 
     def expr_call_super(opcode)
       subject, multiname, *args = opcode.children
@@ -556,7 +761,7 @@ module Furnace::AVM2
         token(CallToken, [
           subject_token,
           token(ArgumentsToken, [
-            token(VariableNameToken, "this"),
+            token(VariableNameToken, local_name(0)),
             *exprs(args)
           ])
         ])
@@ -581,6 +786,10 @@ module Furnace::AVM2
       token(IsToken, parenthesize_each(exprs(opcode.children)))
     end
 
+    def expr_instance_of(opcode)
+      token(InstanceOfToken, parenthesize_each(exprs(opcode.children)))
+    end
+
     def expr_type_of(opcode)
       token(TypeOfToken, exprs(opcode.children))
     end
@@ -594,9 +803,8 @@ module Furnace::AVM2
       ])
     end
 
-    def expr_coerce(opcode)
-      typename, subject, = opcode.children
-      expr(subject)
+    def expr_new_class(opcode)
+      throw :skip
     end
 
     def expr_convert(opcode)
@@ -609,6 +817,69 @@ module Furnace::AVM2
       ])
     end
 
+    ## Closures
+
+    def expr_new_function(opcode)
+      index, = opcode.children
+      body = @method.root.method_body_at(index)
+
+      token(ClosureToken,
+        body)
+    end
+
+    ## XML literals
+
+    # FFFUUUUUUUUUU~~~
+    XmlLiteralMatcher = Matcher.new do
+      [:coerce, [:q, "XML"],
+        [:construct,
+          either[
+            [:get_lex, [:q, "XML"]],
+            [:get_property,
+              [:find_property_strict, [:q, "XML"]], [:q, "XML"]]
+          ],
+          capture(:body),
+        ]
+      ]
+    end
+
+    def expr_coerce(opcode)
+      if captures = XmlLiteralMatcher.match(opcode)
+        # Oh, shit...
+        token(XmlLiteralToken,
+          xml_expr(captures[:body]))
+      else
+        typename, subject, = opcode.children
+        expr(subject)
+      end
+    end
+
+    def xml_expr(node)
+      if respond_to?(:"xml_#{node.type}")
+        send :"xml_#{node.type}", node
+      else
+        "{#{expr(node).to_text}}"
+      end
+    end
+
+    def xml_string(node)
+      node.children.first
+    end
+
+    def xml_add(node)
+      node.children.map do |child|
+        xml_expr child
+      end.join
+    end
+
+    def xml_esc_xattr(node)
+      xml_expr(node.children.first)
+    end
+
+    def xml_esc_xelem(node)
+      xml_expr(node.children.first)
+    end
+
     private
 
     def token(klass, *args)