class ActionView::Template

def compile(mod)

Experimental RBS support (using type sampling data from the type_fusion project). 

def compile: (Class mod) -> untyped

This signature was generated using 1 sample from 1 application.

regardless of the original source encoding.
In general, this means that templates will be UTF-8 inside of Rails,
encode the source into Encoding.default_internal.
Otherwise, after we figure out the correct encoding, we then

specifying the encoding. For instance, ERB supports <%# encoding: %>
the template engine to support additional mechanisms for
String to the engine without further processing. This allows
If the template engine handles encodings, we send the encoded

the encoding of the compiled template.
Among other things, this method is responsible for properly setting 
def compile(mod)
  source = encode!
  code = @handler.call(self, source)
  # Make sure that the resulting String to be eval'd is in the
  # encoding of the code
  original_source = source
  source = +<<-end_src
    def #{method_name}(local_assigns, output_buffer)
      @virtual_path = #{@virtual_path.inspect};#{locals_code};#{code}
    end
  end_src
  # Make sure the source is in the encoding of the returned code
  source.force_encoding(code.encoding)
  # In case we get back a String from a handler that is not in
  # BINARY or the default_internal, encode it to the default_internal
  source.encode!
  # Now, validate that the source we got back from the template
  # handler is valid in the default_internal. This is for handlers
  # that handle encoding but screw up
  unless source.valid_encoding?
    raise WrongEncodingError.new(source, Encoding.default_internal)
  end
  begin
    if Template.frozen_string_literal
      mod.module_eval("# frozen_string_literal: true\n#{source}", identifier, -1)
    else
      mod.module_eval(source, identifier, 0)
    end
  rescue SyntaxError
    # Account for when code in the template is not syntactically valid; e.g. if we're using
    # ERB and the user writes <%= foo( %>, attempting to call a helper `foo` and interpolate
    # the result into the template, but missing an end parenthesis.
    raise SyntaxErrorInTemplate.new(self, original_source)
  end
end