1 files changed, 12 insertions, 12 deletions

diff --git a/src/compiler.rs b/src/compiler.rs
index 2ad9145..10f1433 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 syntactic::*;
+    use SyntacticTokenVariant as SynVar;
     use DefinitionType::*;
     use SymbolRole::*;
     let mut symbols = Vec::new();
@@ -80,41 +80,41 @@ fn parse_symbols(source_code: &str, path: Option<&Path>) -> Vec<Symbol> {
         }
     }
 
-    for token in SyntacticParser::from_source_code(&source_code, path) {
+    let syntactic_tokens = SyntacticParser::new(&source_code, path).parse();
+    for token in syntactic_tokens {
         match token.variant {
-            TokenVariant::MacroDefinition(name) => {
+            SynVar::MacroDefinition(name) => {
                 push!(name.clone(), token.source, Definition(MustPrecedeReference));
                 macro_name = Some(name);
                 parse_arg_list = true;
             }
-            TokenVariant::MacroDefinitionTerminator => {
+            SynVar::MacroDefinitionTerminator => {
                 macro_name = None;
             }
-            TokenVariant::LabelDefinition(name) => {
+            SynVar::LabelDefinition(name) => {
                 push!(name.clone(), token.source, Definition(CanFollowReference));
             }
-            TokenVariant::Symbol(name) => if parse_arg_list && after_separator {
+            SynVar::Symbol(name) => if parse_arg_list && after_separator {
                 push!(name, token.source, Definition(MustPrecedeReference));
             } else {
                 parse_arg_list = false;
                 push!(name, token.source, Reference);
             }
-            TokenVariant::Separator => {
+            SynVar::Separator => {
                 after_separator = true;
                 continue;
             }
-            TokenVariant::BlockOpen | TokenVariant::BlockClose => {
+            SynVar::BlockOpen | SynVar::BlockClose => {
                 continue;
             }
-            TokenVariant::PackedBinaryLiteral(pbl) => {
+            SynVar::PackedBinaryLiteral(pbl) => {
                 for field in pbl.fields {
                     push!(field.name.to_string(), field.source, Reference)
                 }
             }
-            TokenVariant::ConstantExpression(expr) => {
-                use ConstantExpressionTokenVariant as TokenVar;
+            SynVar::Expression(expr) => {
                 for token in expr.tokens {
-                    if let TokenVar::SymbolReference(name) = token.variant {
+                    if let ExpressionTokenVariant::Invocation(name) = token.variant {
                         push!(name, token.source, Reference);
                     }
                 }