Source mapping (#950)

Author: joeldrapper

lib/phlex/compiler.rb

@@ -4,15 +4,51 @@
 require "refract"
 
 module Phlex::Compiler
+	MAP = {}
 	Error = Class.new(StandardError)
 
 	def self.compile(component)
 		path, line = Object.const_source_location(component.name)
-		return unless File.exist?(path)
+		compile_file(path)
+	end
+
+	def self.compile_file(path)
+		unless File.exist?(path)
+			raise ArgumentError, "Can’t compile #{path} because it doesn’t exist."
+		end
+
+		require(path)
+
 		source = File.read(path)
 		tree = Prism.parse(source).value
 		refract = Refract::Converter.new.visit(tree)
 
-		Compilation.new(component, path, line, source, refract).compile
+		last_line = source.count("\n")
+
+		starting_line = last_line + 1
+
+		results = FileCompiler.new.compile(refract)
+
+		result = Refract::StatementsNode.new(
+			body: results.map do |result|
+				result.namespace.reverse_each.reduce(
+					result.compiled_snippets
+				) do |body, scope|
+					scope.copy(
+						body: Refract::StatementsNode.new(
+							body: [body]
+						)
+					)
+				end
+			end
+		)
+
+		formatting_result = Refract::Formatter.new(starting_line:).format_node(result)
+
+		MAP[path] = formatting_result.source_map
+
+		puts formatting_result.source
+
+		eval("# frozen_string_literal: true\n#{formatting_result.source}", TOPLEVEL_BINDING, path, starting_line - 1)
 	end
 end

lib/phlex/compiler/class_compiler.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class Phlex::Compiler::ClassCompiler < Refract::Visitor
-	def initialize(compiler)
+	def initialize(component)
 		super()
-		@compiler = compiler
+		@component = component
 		@compiled_snippets = []
 	end
 
@@ -17,7 +17,7 @@ def compile(node)
 		return if node.receiver
 
 		@compiled_snippets << Phlex::Compiler::MethodCompiler.new(
-			@compiler.component
+			@component
 		).compile(node)
 	end
 

lib/phlex/compiler/compilation.rb

@@ -3,16 +3,15 @@
 class Phlex::Compiler::FileCompiler < Refract::Visitor
 	Result = Data.define(:namespace, :compiled_snippets)
 
-	def initialize(compiler)
-		super()
-		@compiler = compiler
+	def initialize
+		super
 		@current_namespace = []
+		@results = []
 	end
 
 	def compile(node)
-		catch(:phlex_compiler_result) do
-			visit(node)
-		end
+		visit(node)
+		@results.freeze
 	end
 
 	visit Refract::ModuleNode do |node|
@@ -24,10 +23,16 @@ def compile(node)
 	visit Refract::ClassNode do |node|
 		@current_namespace.push(node)
 
-		if @compiler.line == node.start_line
-			throw :phlex_compiler_result, Result.new(
+		namespace = @current_namespace.map do |node|
+			Refract::Formatter.new.format_node(node.constant_path).source
+		end.join("::")
+
+		const = eval(namespace, TOPLEVEL_BINDING)
+
+		if Class === const && Phlex::SGML > const
+			@results << Result.new(
 				namespace: @current_namespace.dup.freeze,
-				compiled_snippets: Phlex::Compiler::ClassCompiler.new(@compiler).compile(node)
+				compiled_snippets: Phlex::Compiler::ClassCompiler.new(const).compile(node)
 			)
 		else
 			super(node)

lib/phlex/compiler/file_compiler.rb

@@ -16,13 +16,11 @@ def compile(node)
 		end
 
 		def around_visit(node)
-			result = super
-
-			# We want to clear the buffer when there’s a node that isn’t a statements node,
-			# but we should ignore nils, which are usually other buffers.
-			clear_buffer unless result in Refract::StatementsNode | nil
+			unless node in Refract::StatementsNode | Refract::CallNode | nil
+				clear_buffer
+			end
 
-			result
+			super
 		end
 
 		visit Refract::ClassNode do |node|
@@ -36,14 +34,49 @@ def around_visit(node)
 		visit Refract::DefNode do |node|
 			if @stack.size == 1
 				node.copy(
-					body: Refract::StatementsNode.new(
-						body: [
-							Refract::StatementsNode.new(
-								body: @preamble
+					body: Refract::BeginNode.new(
+						statements: Refract::StatementsNode.new(
+							body: [
+								Refract::StatementsNode.new(
+									body: @preamble
+								),
+								Refract::NilNode.new,
+								visit(node.body),
+							]
+						),
+						rescue_clause: Refract::RescueNode.new(
+							exceptions: [],
+							reference: Refract::LocalVariableTargetNode.new(
+								name: :__phlex_exception__
 							),
-							Refract::NilNode.new,
-							visit(node.body),
-						]
+							statements: Refract::StatementsNode.new(
+								body: [
+									Refract::CallNode.new(
+										receiver: Refract::ConstantReadNode.new(
+											name: :Kernel
+										),
+										name: :raise,
+										arguments: Refract::ArgumentsNode.new(
+											arguments: [
+												Refract::CallNode.new(
+													name: :__map_exception__,
+													arguments: Refract::ArgumentsNode.new(
+														arguments: [
+															Refract::LocalVariableReadNode.new(
+																name: :__phlex_exception__
+															),
+														]
+													)
+												),
+											]
+										)
+									),
+								]
+							),
+							subsequent: nil
+						),
+						else_clause: nil,
+						ensure_clause: nil
 					)
 				)
 			else
@@ -72,6 +105,7 @@ def around_visit(node)
 				end
 			end
 
+			clear_buffer
 			super(node)
 		end
 
@@ -134,7 +168,8 @@ def compile_phlex_attributes(node)
 					return raw(
 						Phlex::SGML::Attributes.generate_attributes(
 							eval(
-								"{#{Refract::Formatter.new.format_node(node)}}"
+								"{#{Refract::Formatter.new.format_node(node).source}}",
+								TOPLEVEL_BINDING
 							)
 						)
 					)
@@ -253,9 +288,10 @@ def compile_doctype_helper(node)
 		def compile_plain_helper(node)
 			node => Refract::CallNode
 
-			if node.arguments in [Refract::StringNode]
+			if node.arguments.arguments in [Refract::StringNode]
 				raw(node.arguments.arguments.first.unescaped)
 			else
+				clear_buffer
 				node
 			end
 		end
@@ -315,6 +351,8 @@ def compile_comment_helper(node)
 
 		def compile_raw_helper(node)
 			node => Refract::CallNode
+
+			clear_buffer
 			node
 		end
 
@@ -373,28 +411,33 @@ def compile_raw_helper(node)
 			else
 				@current_buffer = [node]
 
-				Refract::IfNode.new(
-					inline: false,
-					predicate: Refract::LocalVariableReadNode.new(
-						name: should_render_local
-					),
-					statements: Refract::StatementsNode.new(
-						body: [
-							Refract::CallNode.new(
-								receiver: Refract::CallNode.new(
-									name: buffer_local,
-								),
-								name: :<<,
-								arguments: Refract::ArgumentsNode.new(
-									arguments: [
-										Refract::InterpolatedStringNode.new(
-											parts: @current_buffer
-										),
-									]
-								)
+				Refract::StatementsNode.new(
+					body: [
+						Refract::IfNode.new(
+							inline: false,
+							predicate: Refract::LocalVariableReadNode.new(
+								name: should_render_local
 							),
-						]
-					)
+							statements: Refract::StatementsNode.new(
+								body: [
+									Refract::CallNode.new(
+										receiver: Refract::CallNode.new(
+											name: buffer_local,
+										),
+										name: :<<,
+										arguments: Refract::ArgumentsNode.new(
+											arguments: [
+												Refract::InterpolatedStringNode.new(
+													parts: @current_buffer
+												),
+											]
+										)
+									),
+								]
+							)
+						),
+						Refract::NilNode.new,
+					]
 				)
 			end
 		end

lib/phlex/compiler/method_compiler.rb

@@ -481,4 +481,18 @@ def self.__compile__(method_name)
 		path, line = instance_method(method_name).source_location
 		Phlex::Compiler::Method.new(self, path, line, method_name).compile
 	end
+
+	def __map_exception__(exception)
+		exception.set_backtrace(
+			exception.backtrace_locations.map do |loc|
+				if ((map = Phlex::Compiler::MAP[loc.path]) && (line = map[loc.lineno]))
+					"[Phlex] #{loc.path}:#{line}:#{loc.label}"
+				else
+					"#{loc.path}:#{loc.lineno}:#{loc.label}"
+				end
+			end
+		)
+
+		exception
+	end
 end