Separate syntactic and semantic token types by namespace

This will allow type names to be shared by both types of token.

1 files changed, 9 insertions, 9 deletions

diff --git a/src/compiler.rs b/src/compiler.rs
index 068c6d5..2ad9145 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -58,7 +58,7 @@ impl Compiler {
 
 /// Parse all symbols from a source code string.
 fn parse_symbols(source_code: &str, path: Option<&Path>) -> Vec<Symbol> {
-    use SyntacticTokenVariant as SynVar;
+    use syntactic::*;
     use DefinitionType::*;
     use SymbolRole::*;
     let mut symbols = Vec::new();
@@ -82,36 +82,36 @@ fn parse_symbols(source_code: &str, path: Option<&Path>) -> Vec<Symbol> {
 
     for token in SyntacticParser::from_source_code(&source_code, path) {
         match token.variant {
-            SynVar::MacroDefinition(name) => {
+            TokenVariant::MacroDefinition(name) => {
                 push!(name.clone(), token.source, Definition(MustPrecedeReference));
                 macro_name = Some(name);
                 parse_arg_list = true;
             }
-            SynVar::MacroDefinitionTerminator => {
+            TokenVariant::MacroDefinitionTerminator => {
                 macro_name = None;
             }
-            SynVar::LabelDefinition(name) => {
+            TokenVariant::LabelDefinition(name) => {
                 push!(name.clone(), token.source, Definition(CanFollowReference));
             }
-            SynVar::Symbol(name) => if parse_arg_list && after_separator {
+            TokenVariant::Symbol(name) => if parse_arg_list && after_separator {
                 push!(name, token.source, Definition(MustPrecedeReference));
             } else {
                 parse_arg_list = false;
                 push!(name, token.source, Reference);
             }
-            SynVar::Separator => {
+            TokenVariant::Separator => {
                 after_separator = true;
                 continue;
             }
-            SynVar::BlockOpen | SynVar::BlockClose => {
+            TokenVariant::BlockOpen | TokenVariant::BlockClose => {
                 continue;
             }
-            SynVar::PackedBinaryLiteral(pbl) => {
+            TokenVariant::PackedBinaryLiteral(pbl) => {
                 for field in pbl.fields {
                     push!(field.name.to_string(), field.source, Reference)
                 }
             }
-            SynVar::ConstantExpression(expr) => {
+            TokenVariant::ConstantExpression(expr) => {
                 use ConstantExpressionTokenVariant as TokenVar;
                 for token in expr.tokens {
                     if let TokenVar::SymbolReference(name) = token.variant {