From: Michael D. Lowis <mike@mdlowis.com>
Date: Tue, 28 Oct 2014 17:12:54 +0000 (-0400)
Subject: Rename T_VAR to T_ID to better reflect it's usage
X-Git-Url: https://git.mdlowis.com/?a=commitdiff_plain;h=217436e596b5a38d32f0cd66419941128280f479;p=proto%2Fsclpl.git

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 cdf6b31..a8bf968 100644
--- 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 57016ca..f22ee3f 100644
--- 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