Rename T_VAR to T_ID to better reflect it's usage

diff --git a/spec/lexer_spec.rb b/spec/lexer_spec.rb
index cdf6b312190adae2b0732ffcf98ac6d93d935440..a8bf968bb7ff5e11474034877e38b7efd0b26f25 100644 (file)
--- a/spec/lexer_spec.rb
+++ b/spec/lexer_spec.rb
@@ -71,7 +71,7 @@ describe "lexer" do
     end
 
     it "should recognize invalid named characters as identifiers" do
-      expect(lexer('\foobar')).to eq ['T_VAR:\foobar']
+      expect(lexer('\foobar')).to eq ['T_ID:\foobar']
     end
   end
 
@@ -90,7 +90,7 @@ describe "lexer" do
       end
 
       it "should recognize invalid ints as identifiers" do
-        expect(lexer('123a')).to eq ['T_VAR:123a']
+        expect(lexer('123a')).to eq ['T_ID:123a']
       end
     end
 
@@ -112,7 +112,7 @@ describe "lexer" do
       end
 
       it "should recognize invalid radix ints as identifiers" do
-        expect(lexer('0b012')).to eq ['T_VAR:0b012']
+        expect(lexer('0b012')).to eq ['T_ID:0b012']
       end
     end
 
@@ -130,7 +130,7 @@ describe "lexer" do
       end
 
       it "should recognize invalid floats as identifiers" do
-        expect(lexer('123..0')).to eq ['T_VAR:123..0']
+        expect(lexer('123..0')).to eq ['T_ID:123..0']
       end
     end
   end
@@ -147,7 +147,7 @@ describe "lexer" do
 
   context "identifiers" do
     it "should recognize an identifier" do
-      expect(lexer('foo')).to eq ['T_VAR:foo']
+      expect(lexer('foo')).to eq ['T_ID:foo']
     end
   end
 

diff --git a/spec/parser_spec.rb b/spec/parser_spec.rb
index 57016cafd3fe455898de678dbdeaf8b389fffc28..f22ee3f9a662d27a45419c208f81b1f4e243e06e 100644 (file)
--- a/spec/parser_spec.rb
+++ b/spec/parser_spec.rb
@@ -3,11 +3,11 @@ require 'open3'
 describe "sclpl grammar" do
   context "requires" do
     it "should parse a require statement" do
-      expect(ast('require "foo";')).to eq([ ['T_VAR:require', 'T_STRING:"foo"'] ])
+      expect(ast('require "foo";')).to eq([ ['T_ID:require', 'T_STRING:"foo"'] ])
     end
 
     it "should parse a require statement using end keyword" do
-        expect(ast('require "foo" end')).to eq([ ['T_VAR:require', 'T_STRING:"foo"'] ])
+        expect(ast('require "foo" end')).to eq([ ['T_ID:require', 'T_STRING:"foo"'] ])
     end
 
     it "should error on missing semicolon" do
@@ -29,32 +29,32 @@ describe "sclpl grammar" do
 
   context "definitions" do
     it "should parse a value definition" do
-      expect(ast('def foo 123;')).to eq([ ['T_VAR:def', 'T_VAR:foo', 'T_INT:123'] ])
+      expect(ast('def foo 123;')).to eq([ ['T_ID:def', 'T_ID:foo', 'T_INT:123'] ])
     end
 
     it "should parse a function definition" do
       expect(ast('def foo() 123;')).to eq([
-        ['T_VAR:def', 'T_VAR:foo', ['T_VAR:fn', [], 'T_INT:123']] ])
+        ['T_ID:def', 'T_ID:foo', ['T_ID:fn', [], 'T_INT:123']] ])
     end
 
     it "should parse a function definition  with multiple expressions in the body" do
       expect(ast('def foo() 123 321;')).to eq([
-        ['T_VAR:def', 'T_VAR:foo', ['T_VAR:fn', [], 'T_INT:123', 'T_INT:321']] ])
+        ['T_ID:def', 'T_ID:foo', ['T_ID:fn', [], 'T_INT:123', 'T_INT:321']] ])
     end
 
     it "should parse a function definition with one argument" do
       expect(ast('def foo(a) 123;')).to eq([
-        ['T_VAR:def', 'T_VAR:foo', ['T_VAR:fn', ['T_VAR:a'], 'T_INT:123']] ])
+        ['T_ID:def', 'T_ID:foo', ['T_ID:fn', ['T_ID:a'], 'T_INT:123']] ])
     end
 
     it "should parse a function definition with two arguments" do
       expect(ast('def foo(a,b) 123;')).to eq([
-        ['T_VAR:def', 'T_VAR:foo', ['T_VAR:fn', ['T_VAR:a', 'T_VAR:b'], 'T_INT:123']] ])
+        ['T_ID:def', 'T_ID:foo', ['T_ID:fn', ['T_ID:a', 'T_ID:b'], 'T_INT:123']] ])
     end
 
     it "should parse a function definition with three arguments" do
       expect(ast('def foo(a,b,c) 123;')).to eq([
-        ['T_VAR:def', 'T_VAR:foo', ['T_VAR:fn', ['T_VAR:a', 'T_VAR:b', 'T_VAR:c'], 'T_INT:123']] ])
+        ['T_ID:def', 'T_ID:foo', ['T_ID:fn', ['T_ID:a', 'T_ID:b', 'T_ID:c'], 'T_INT:123']] ])
     end
   end
 
@@ -71,40 +71,40 @@ describe "sclpl grammar" do
 
     context "if statements" do
       it "should parse an if statement with no else clause" do
-        expect(ast('if 123 321 end')).to eq([["T_VAR:if", "T_INT:123", "T_INT:321"]])
+        expect(ast('if 123 321 end')).to eq([["T_ID:if", "T_INT:123", "T_INT:321"]])
       end
 
       it "should parse an if statement with an else clause " do
         expect(ast('if 123 321 else 456 end')).to eq([
-          ["T_VAR:if", "T_INT:123", "T_INT:321", "T_VAR:else", "T_INT:456"]])
+          ["T_ID:if", "T_INT:123", "T_INT:321", "T_ID:else", "T_INT:456"]])
       end
     end
 
     context "function literals" do
       it "should parse a function with no params" do
-        expect(ast('fn() 123;')).to eq([["T_VAR:fn", [], "T_INT:123"]])
+        expect(ast('fn() 123;')).to eq([["T_ID:fn", [], "T_INT:123"]])
       end
 
       it "should parse a function with one param" do
-        expect(ast('fn(a) 123;')).to eq([["T_VAR:fn", ["T_VAR:a"], "T_INT:123"]])
+        expect(ast('fn(a) 123;')).to eq([["T_ID:fn", ["T_ID:a"], "T_INT:123"]])
       end
 
       it "should parse a function with two params" do
-        expect(ast('fn(a,b) 123;')).to eq([["T_VAR:fn", ["T_VAR:a", "T_VAR:b"], "T_INT:123"]])
+        expect(ast('fn(a,b) 123;')).to eq([["T_ID:fn", ["T_ID:a", "T_ID:b"], "T_INT:123"]])
       end
     end
 
     context "function application" do
       it "should parse an application with no params " do
-        expect(ast('foo()')).to eq([["T_VAR:foo"]])
+        expect(ast('foo()')).to eq([["T_ID:foo"]])
       end
 
       it "should parse an application with one param" do
-        expect(ast('foo(a)')).to eq([["T_VAR:foo", "T_VAR:a"]])
+        expect(ast('foo(a)')).to eq([["T_ID:foo", "T_ID:a"]])
       end
 
       it "should parse an application with two params" do
-        expect(ast('foo(a,b)')).to eq([["T_VAR:foo", "T_VAR:a", "T_VAR:b"]])
+        expect(ast('foo(a,b)')).to eq([["T_ID:foo", "T_ID:a", "T_ID:b"]])
       end
     end
   end
@@ -131,7 +131,7 @@ describe "sclpl grammar" do
     end
 
     it "should parse an identifier" do
-      expect(ast('foo')).to eq(['T_VAR:foo'])
+      expect(ast('foo')).to eq(['T_ID:foo'])
     end
   end