465 lines
14 KiB
Crystal
465 lines
14 KiB
Crystal
require "../../spec_helper"
|
|
|
|
module Ameba::AST
|
|
struct Test
|
|
include Util
|
|
end
|
|
|
|
subject = Test.new
|
|
|
|
describe Util do
|
|
describe "#literal?" do
|
|
[
|
|
Crystal::ArrayLiteral.new,
|
|
Crystal::BoolLiteral.new(false),
|
|
Crystal::CharLiteral.new('a'),
|
|
Crystal::HashLiteral.new,
|
|
Crystal::NamedTupleLiteral.new,
|
|
Crystal::NilLiteral.new,
|
|
Crystal::NumberLiteral.new(42),
|
|
Crystal::RegexLiteral.new(Crystal::StringLiteral.new("")),
|
|
Crystal::StringLiteral.new(""),
|
|
Crystal::SymbolLiteral.new(""),
|
|
Crystal::TupleLiteral.new([] of Crystal::ASTNode),
|
|
Crystal::RangeLiteral.new(
|
|
Crystal::NilLiteral.new,
|
|
Crystal::NilLiteral.new,
|
|
true),
|
|
].each do |literal|
|
|
it "returns true if node is #{literal}" do
|
|
subject.literal?(literal).should be_true
|
|
end
|
|
end
|
|
|
|
it "returns false if node is not a literal" do
|
|
subject.literal?(Crystal::Nop).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#static/dynamic_literal?" do
|
|
[
|
|
Crystal::ArrayLiteral.new,
|
|
Crystal::ArrayLiteral.new([Crystal::StringLiteral.new("foo")] of Crystal::ASTNode),
|
|
Crystal::BoolLiteral.new(false),
|
|
Crystal::CharLiteral.new('a'),
|
|
Crystal::HashLiteral.new,
|
|
Crystal::NamedTupleLiteral.new,
|
|
Crystal::NilLiteral.new,
|
|
Crystal::NumberLiteral.new(42),
|
|
Crystal::RegexLiteral.new(Crystal::StringLiteral.new("")),
|
|
Crystal::StringLiteral.new("foo"),
|
|
Crystal::SymbolLiteral.new("foo"),
|
|
Crystal::TupleLiteral.new([] of Crystal::ASTNode),
|
|
Crystal::TupleLiteral.new([Crystal::StringLiteral.new("foo")] of Crystal::ASTNode),
|
|
Crystal::RangeLiteral.new(
|
|
Crystal::NumberLiteral.new(0),
|
|
Crystal::NumberLiteral.new(10),
|
|
true),
|
|
].each do |literal|
|
|
it "properly identifies static node #{literal}" do
|
|
subject.static_literal?(literal).should be_true
|
|
subject.dynamic_literal?(literal).should be_false
|
|
end
|
|
end
|
|
|
|
[
|
|
Crystal::ArrayLiteral.new([Crystal::Path.new(%w[IO])] of Crystal::ASTNode),
|
|
Crystal::TupleLiteral.new([Crystal::Path.new(%w[IO])] of Crystal::ASTNode),
|
|
].each do |literal|
|
|
it "properly identifies dynamic node #{literal}" do
|
|
subject.dynamic_literal?(literal).should be_true
|
|
subject.static_literal?(literal).should be_false
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#node_source" do
|
|
it "returns original source of the node" do
|
|
s = <<-CRYSTAL
|
|
a = 1
|
|
CRYSTAL
|
|
node = Crystal::Parser.new(s).parse
|
|
source = subject.node_source node, s.split("\n")
|
|
source.should eq "a = 1"
|
|
end
|
|
|
|
it "returns original source of multiline node" do
|
|
s = <<-CRYSTAL
|
|
if ()
|
|
:ok
|
|
end
|
|
CRYSTAL
|
|
node = Crystal::Parser.new(s).parse
|
|
source = subject.node_source node, s.split("\n")
|
|
source.should eq <<-CRYSTAL
|
|
if ()
|
|
:ok
|
|
end
|
|
CRYSTAL
|
|
end
|
|
|
|
it "does not report source of node which has incorrect location" do
|
|
s = <<-'CRYSTAL'
|
|
module MyModule
|
|
macro conditional_error_for_inline_callbacks
|
|
\{%
|
|
raise ""
|
|
%}
|
|
end
|
|
|
|
macro before_save(x = nil)
|
|
end
|
|
end
|
|
CRYSTAL
|
|
node = as_nodes(s).nil_literal_nodes.first
|
|
source = subject.node_source node, s.split("\n")
|
|
source.should eq "nil"
|
|
end
|
|
end
|
|
|
|
describe "#flow_command?" do
|
|
it "returns true if this is return" do
|
|
node = as_node("return 22")
|
|
subject.flow_command?(node, false).should eq true
|
|
end
|
|
|
|
it "returns true if this is a break in a loop" do
|
|
node = as_node("break")
|
|
subject.flow_command?(node, true).should eq true
|
|
end
|
|
|
|
it "returns false if this is a break out of loop" do
|
|
node = as_node("break")
|
|
subject.flow_command?(node, false).should be_false
|
|
end
|
|
|
|
it "returns true if this is a next in a loop" do
|
|
node = as_node("next")
|
|
subject.flow_command?(node, true).should eq true
|
|
end
|
|
|
|
it "returns false if this is a next out of loop" do
|
|
node = as_node("next")
|
|
subject.flow_command?(node, false).should be_false
|
|
end
|
|
|
|
it "returns true if this is raise" do
|
|
node = as_node("raise e")
|
|
subject.flow_command?(node, false).should eq true
|
|
end
|
|
|
|
it "returns true if this is exit" do
|
|
node = as_node("exit")
|
|
subject.flow_command?(node, false).should eq true
|
|
end
|
|
|
|
it "returns true if this is abort" do
|
|
node = as_node("abort")
|
|
subject.flow_command?(node, false).should eq true
|
|
end
|
|
|
|
it "returns false otherwise" do
|
|
node = as_node("foobar")
|
|
subject.flow_command?(node, false).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#flow_expression?" do
|
|
it "returns true if this is a flow command" do
|
|
node = as_node("return")
|
|
subject.flow_expression?(node, true).should eq true
|
|
end
|
|
|
|
it "returns true if this is if-else consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
if foo
|
|
return :foo
|
|
else
|
|
return :bar
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node, false).should eq true
|
|
end
|
|
|
|
it "returns true if this is unless-else consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
unless foo
|
|
return :foo
|
|
else
|
|
return :bar
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this is case consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
case
|
|
when 1
|
|
return 1
|
|
when 2
|
|
return 2
|
|
else
|
|
return 3
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this is exception handler consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
begin
|
|
raise "exp"
|
|
rescue e
|
|
return e
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this while consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
while true
|
|
return
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns false if this while with break" do
|
|
node = as_node <<-CRYSTAL
|
|
while true
|
|
break
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should be_false
|
|
end
|
|
|
|
it "returns true if this until consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
until false
|
|
return
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns false if this until with break" do
|
|
node = as_node <<-CRYSTAL
|
|
until false
|
|
break
|
|
end
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should be_false
|
|
end
|
|
|
|
it "returns true if this expressions consumed by flow expressions" do
|
|
node = as_node <<-CRYSTAL
|
|
exp1
|
|
exp2
|
|
return
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should eq true
|
|
end
|
|
|
|
it "returns false otherwise" do
|
|
node = as_node <<-CRYSTAL
|
|
exp1
|
|
exp2
|
|
CRYSTAL
|
|
subject.flow_expression?(node).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#raise?" do
|
|
it "returns true if this is a raise method call" do
|
|
node = as_node "raise e"
|
|
subject.raise?(node).should eq true
|
|
end
|
|
|
|
it "returns false if it has a receiver" do
|
|
node = as_node "obj.raise e"
|
|
subject.raise?(node).should be_false
|
|
end
|
|
|
|
it "returns false if size of the arguments doesn't match" do
|
|
node = as_node "raise"
|
|
subject.raise?(node).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#exit?" do
|
|
it "returns true if this is a exit method call" do
|
|
node = as_node "exit"
|
|
subject.exit?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this is a exit method call with one argument" do
|
|
node = as_node "exit 1"
|
|
subject.exit?(node).should eq true
|
|
end
|
|
|
|
it "returns false if it has a receiver" do
|
|
node = as_node "obj.exit"
|
|
subject.exit?(node).should be_false
|
|
end
|
|
|
|
it "returns false if size of the arguments doesn't match" do
|
|
node = as_node "exit 1, 1"
|
|
subject.exit?(node).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#abort?" do
|
|
it "returns true if this is an abort method call" do
|
|
node = as_node "abort"
|
|
subject.abort?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this is an abort method call with one argument" do
|
|
node = as_node "abort \"message\""
|
|
subject.abort?(node).should eq true
|
|
end
|
|
|
|
it "returns true if this is an abort method call with two arguments" do
|
|
node = as_node "abort \"message\", 1"
|
|
subject.abort?(node).should eq true
|
|
end
|
|
|
|
it "returns false if it has a receiver" do
|
|
node = as_node "obj.abort"
|
|
subject.abort?(node).should be_false
|
|
end
|
|
|
|
it "returns false if size of the arguments doesn't match" do
|
|
node = as_node "abort 1, 1, 1"
|
|
subject.abort?(node).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#loop?" do
|
|
it "returns true if this is a loop method call" do
|
|
node = as_node "loop"
|
|
subject.loop?(node).should eq true
|
|
end
|
|
|
|
it "returns false if it has a receiver" do
|
|
node = as_node "obj.loop"
|
|
subject.loop?(node).should be_false
|
|
end
|
|
|
|
it "returns false if size of the arguments doesn't match" do
|
|
node = as_node "loop 1"
|
|
subject.loop?(node).should be_false
|
|
end
|
|
end
|
|
|
|
describe "#control_exp_code" do
|
|
it "returns the exp code of a control expression" do
|
|
s = "return 1"
|
|
node = as_node(s).as Crystal::ControlExpression
|
|
exp_code = subject.control_exp_code node, [s]
|
|
exp_code.should eq "1"
|
|
end
|
|
|
|
it "wraps implicit tuple literal with curly brackets" do
|
|
s = "return 1, 2"
|
|
node = as_node(s).as Crystal::ControlExpression
|
|
exp_code = subject.control_exp_code node, [s]
|
|
exp_code.should eq "{1, 2}"
|
|
end
|
|
|
|
it "accepts explicit tuple literal" do
|
|
s = "return {1, 2}"
|
|
node = as_node(s).as Crystal::ControlExpression
|
|
exp_code = subject.control_exp_code node, [s]
|
|
exp_code.should eq "{1, 2}"
|
|
end
|
|
end
|
|
|
|
describe "#name_end_location" do
|
|
it "works on method call" do
|
|
node = as_node("name(foo)").as Crystal::Call
|
|
subject.name_end_location(node).to_s.should eq ":1:4"
|
|
end
|
|
|
|
it "works on method definition" do
|
|
node = as_node("def name; end").as Crystal::Def
|
|
subject.name_end_location(node).to_s.should eq ":1:8"
|
|
end
|
|
|
|
it "works on macro definition" do
|
|
node = as_node("macro name; end").as Crystal::Macro
|
|
subject.name_end_location(node).to_s.should eq ":1:10"
|
|
end
|
|
|
|
it "works on class definition" do
|
|
node = as_node("class Name; end").as Crystal::ClassDef
|
|
subject.name_end_location(node).to_s.should eq ":1:10"
|
|
end
|
|
|
|
it "works on module definition" do
|
|
node = as_node("module Name; end").as Crystal::ModuleDef
|
|
subject.name_end_location(node).to_s.should eq ":1:11"
|
|
end
|
|
|
|
it "works on annotation definition" do
|
|
node = as_node("annotation Name; end").as Crystal::AnnotationDef
|
|
subject.name_end_location(node).to_s.should eq ":1:15"
|
|
end
|
|
|
|
it "works on enum definition" do
|
|
node = as_node("enum Name; end").as Crystal::EnumDef
|
|
subject.name_end_location(node).to_s.should eq ":1:9"
|
|
end
|
|
|
|
it "works on alias definition" do
|
|
node = as_node("alias Name = Foo").as Crystal::Alias
|
|
subject.name_end_location(node).to_s.should eq ":1:10"
|
|
end
|
|
|
|
it "works on generic" do
|
|
node = as_node("Name(Foo)").as Crystal::Generic
|
|
subject.name_end_location(node).to_s.should eq ":1:4"
|
|
end
|
|
|
|
it "works on include" do
|
|
node = as_node("include Name").as Crystal::Include
|
|
subject.name_end_location(node).to_s.should eq ":1:12"
|
|
end
|
|
|
|
it "works on extend" do
|
|
node = as_node("extend Name").as Crystal::Extend
|
|
subject.name_end_location(node).to_s.should eq ":1:11"
|
|
end
|
|
|
|
it "works on variable type declaration" do
|
|
node = as_node("name : Foo").as Crystal::TypeDeclaration
|
|
subject.name_end_location(node).to_s.should eq ":1:4"
|
|
end
|
|
|
|
it "works on uninitialized variable" do
|
|
node = as_node("name = uninitialized Foo").as Crystal::UninitializedVar
|
|
subject.name_end_location(node).to_s.should eq ":1:4"
|
|
end
|
|
|
|
it "works on lib definition" do
|
|
node = as_node("lib Name; end").as Crystal::LibDef
|
|
subject.name_end_location(node).to_s.should eq ":1:8"
|
|
end
|
|
|
|
it "works on lib type definition" do
|
|
node = as_node("lib Foo; type Name = Bar; end").as(Crystal::LibDef).body
|
|
node.class.should eq Crystal::TypeDef
|
|
subject.name_end_location(node).to_s.should eq ":1:18"
|
|
end
|
|
|
|
it "works on metaclass" do
|
|
node = as_node("foo : Name.class").as(Crystal::TypeDeclaration).declared_type
|
|
node.class.should eq Crystal::Metaclass
|
|
subject.name_end_location(node).to_s.should eq ":1:10"
|
|
end
|
|
end
|
|
end
|
|
end
|