CSY/reowolf Changeset - e16722f0d0ac · Centrum Wiskunde & Informatica (CWI)

Changeset - e16722f0d0ac

Parent rev.

Child rev.

[Not reviewed]

2 1 1

Hans-Dieter Hiep - 5 years ago 2020-02-10 15:48:57
hdh@cwi.nl

Lift parser restriction on assignable expressions

3 files changed with 5 insertions and 8 deletions:

src/protocol/parser.rs

testdata/parser/negative/20.txt

testdata/parser/positive/20.pdl

rename

0 comments (0 inline, 0 general)

src/protocol/parser.rs

➞

Show inline comments

@@ @@ -810,1074 +810,1074 @@ impl Visitor for BuildSymbolDeclarations { @@
             .alloc_defined_declaration(|this| DefinedDeclaration { this, definition, signature })
             .upcast();
         self.checked_add(h, decl)?;
         Ok(())
+    }
+}
 struct LinkCallExpressions {
     pd: Option<RootId>,
     composite: bool,
     new_statement: bool,
+}
 impl LinkCallExpressions {
     fn new() -> Self {
         LinkCallExpressions { pd: None, composite: false, new_statement: false }
+    }
     fn get_declaration(
         &self,
         h: &Heap,
         id: SourceIdentifierId,
     ) -> Result<DeclarationId, ParseError> {
         match h[self.pd.unwrap()].get_declaration(h, id.upcast()) {
             Some(id) => Ok(id),
             None => Err(ParseError::new(h[id].position, "Unresolved method")),
+        }
+    }
+}
 impl Visitor for LinkCallExpressions {
     fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {
         self.pd = Some(pd);
         recursive_protocol_description(self, h, pd)?;
         self.pd = None;
         Ok(())
+    }
     fn visit_composite_definition(&mut self, h: &mut Heap, def: CompositeId) -> VisitorResult {
         assert!(!self.composite);
         self.composite = true;
         recursive_composite_definition(self, h, def)?;
         self.composite = false;
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         assert!(self.composite);
         assert!(!self.new_statement);
         self.new_statement = true;
         recursive_new_statement(self, h, stmt)?;
         self.new_statement = false;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if let Method::Symbolic(id) = h[expr].method {
             let decl = self.get_declaration(h, id)?;
             if self.new_statement && h[decl].is_function() {
                 return Err(ParseError::new(h[id].position, "Illegal call expression"));
+            }
             if !self.new_statement && h[decl].is_component() {
                 return Err(ParseError::new(h[id].position, "Illegal call expression"));
+            }
             // Set the corresponding declaration of the call
             h[expr].declaration = Some(decl);
+        }
         // A new statement's call expression may have as arguments function calls
         let old = self.new_statement;
         self.new_statement = false;
         recursive_call_expression(self, h, expr)?;
         self.new_statement = old;
         Ok(())
+    }
+}
 struct BuildScope {
     scope: Option<Scope>,
+}
 impl BuildScope {
     fn new() -> Self {
         BuildScope { scope: None }
+    }
+}
 impl Visitor for BuildScope {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.scope.is_none());
         self.scope = Some(Scope::Definition(def));
         recursive_symbol_definition(self, h, def)?;
         self.scope = None;
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current block
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current sync
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct ResolveVariables {
     scope: Option<Scope>,
+}
 impl ResolveVariables {
     fn new() -> Self {
         ResolveVariables { scope: None }
+    }
     fn get_variable(&self, h: &Heap, id: SourceIdentifierId) -> Result<VariableId, ParseError> {
         if let Some(var) = self.find_variable(h, id) {
             Ok(var)
         } else {
             Err(ParseError::new(h[id].position, "Unresolved variable"))
+        }
+    }
     fn find_variable(&self, h: &Heap, id: SourceIdentifierId) -> Option<VariableId> {
         ResolveVariables::find_variable_impl(h, self.scope, id)
+    }
     fn find_variable_impl(
         h: &Heap,
         scope: Option<Scope>,
         id: SourceIdentifierId,
     ) -> Option<VariableId> {
         if let Some(scope) = scope {
             // The order in which we check for variables is important:
             // otherwise, two variables with the same name are shadowed.
             if let Some(var) = ResolveVariables::find_variable_impl(h, scope.parent_scope(h), id) {
                 Some(var)
             } else {
                 scope.get_variable(h, id)
+            }
         } else {
             None
+        }
+    }
+}
 impl Visitor for ResolveVariables {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.scope.is_none());
         self.scope = Some(Scope::Definition(def));
         recursive_symbol_definition(self, h, def)?;
         self.scope = None;
         Ok(())
+    }
     fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         // This is only called for parameters of definitions and synchronous statements,
         // since the local variables of block statements are still empty
         // the moment it is traversed. After resolving variables, this
         // function is also called for every local variable declaration.
         // We want to make sure that the resolved variable is the variable declared itself;
         // otherwise, there is some variable defined in the parent scope. This check
         // imposes that the order in which find_variable looks is significant!
         let id = h[decl].identifier();
         let check_same = self.find_variable(h, id);
         if let Some(check_same) = check_same {
             if check_same != decl {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
+        }
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let var = h[stmt].variable;
         let id = h[var].identifier;
         // First check whether variable with same identifier is in scope
         let check_duplicate = self.find_variable(h, id);
         if !check_duplicate.is_none() {
             return Err(ParseError::new(h[id].position, "Declared variable clash"));
+        }
         // Then check the expression's variables (this should not refer to own variable)
         recursive_memory_statement(self, h, stmt)?;
         // Finally, we may add the variable to the scope, which is guaranteed to be a block
+        {
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         // First handle the from variable
+        {
             let var = h[stmt].from;
             let id = h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if !check_duplicate.is_none() {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         // Then handle the to variable (which may not be the same as the from)
+        {
             let var = h[stmt].to;
             let id = h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if !check_duplicate.is_none() {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         h: &mut Heap,
         expr: VariableExpressionId,
     ) -> VisitorResult {
         let var = self.get_variable(h, h[expr].identifier)?;
         h[expr].declaration = Some(var);
         Ok(())
+    }
+}
 struct UniqueStatementId(StatementId);
 struct LinkStatements {
     prev: Option<UniqueStatementId>,
+}
 impl LinkStatements {
     fn new() -> Self {
         LinkStatements { prev: None }
+    }
+}
 impl Visitor for LinkStatements {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.prev.is_none());
         recursive_symbol_definition(self, h, def)?;
         // Clear out last statement
         self.prev = None;
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, which combines both branches into one next statement
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_if_statement(|this| EndIfStatement { this, position, next: None }).upcast();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].true_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].false_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         // Use the pseudo-statement as the statement where to update the next pointer
         self.prev = Some(UniqueStatementId(pseudo));
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, to which the break statement finds its target
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_while_statement(|this| EndWhileStatement { this, position, next: None });
         // Update the while's next statement to point to the pseudo-statement
         h[stmt].next = Some(pseudo);
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement loops back to the while statement itself
         // Note: continue statements also loop back to the while statement itself
         if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
             h[prev].link_next(stmt.upcast());
+        }
         // Use the while statement as the statement where the next pointer is updated
         self.prev = Some(UniqueStatementId(pseudo.upcast()));
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command
         // that marks the end of the synchronous block. Every evaluation has to pause at this
         // point, only to resume later when the thread is selected as unique thread to continue.
         let position = h[stmt].position;
         let pseudo = h
             .alloc_end_synchronous_statement(|this| EndSynchronousStatement {
                 this,
                 position,
                 next: None,
             })
             .upcast();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement points to the pseudo element
         if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
             h[prev].link_next(pseudo);
+        }
         // Use the pseudo-statement as the statement where the next pointer is updated
         self.prev = Some(UniqueStatementId(pseudo));
         Ok(())
+    }
     fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_put_statement(&mut self, h: &mut Heap, stmt: PutStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression_statement(
         &mut self,
         h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct BuildLabels {
     block: Option<BlockStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl BuildLabels {
     fn new() -> Self {
         BuildLabels { block: None, sync_enclosure: None }
+    }
+}
 impl Visitor for BuildLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         // Store label in current block (on the fly)
         h[self.block.unwrap()].labels.push(stmt);
         // Update synchronous scope of label
         h[stmt].in_sync = self.sync_enclosure;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         h[stmt].in_sync = self.sync_enclosure;
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct ResolveLabels {
     block: Option<BlockStatementId>,
     while_enclosure: Option<WhileStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl ResolveLabels {
     fn new() -> Self {
         ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }
+    }
     fn check_duplicate_impl(
         h: &Heap,
         block: Option<BlockStatementId>,
         stmt: LabeledStatementId,
     ) -> VisitorResult {
         if let Some(block) = block {
             // Checking the parent first is important. Otherwise, labels
             // overshadow previously defined labels: and this is illegal!
             ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;
             // For the current block, check for a duplicate.
             for &other_stmt in h[block].labels.iter() {
                 if other_stmt == stmt {
                     continue;
                 } else {
                     if h[h[other_stmt].label] == h[h[stmt].label] {
                         return Err(ParseError::new(h[stmt].position, "Duplicate label"));
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn check_duplicate(&self, h: &Heap, stmt: LabeledStatementId) -> VisitorResult {
         ResolveLabels::check_duplicate_impl(h, self.block, stmt)
+    }
     fn get_target(
         &self,
         h: &Heap,
         id: SourceIdentifierId,
     ) -> Result<LabeledStatementId, ParseError> {
         if let Some(stmt) = ResolveLabels::find_target(h, self.block, id) {
             Ok(stmt)
         } else {
             Err(ParseError::new(h[id].position, "Unresolved label"))
+        }
+    }
     fn find_target(
         h: &Heap,
         block: Option<BlockStatementId>,
         id: SourceIdentifierId,
     ) -> Option<LabeledStatementId> {
         if let Some(block) = block {
             // It does not matter in what order we find the labels.
             // If there are duplicates: that is checked elsewhere.
             for &stmt in h[block].labels.iter() {
                 if h[h[stmt].label] == h[id] {
                     return Some(stmt);
+                }
+            }
             if let Some(stmt) = ResolveLabels::find_target(h, h[block].parent_block(h), id) {
                 return Some(stmt);
+            }
+        }
         None
+    }
+}
 impl Visitor for ResolveLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         self.check_duplicate(h, stmt)?;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         let old = self.while_enclosure;
         self.while_enclosure = Some(stmt);
         recursive_while_statement(self, h, stmt)?;
         self.while_enclosure = old;
         Ok(())
+    }
     fn visit_break_statement(&mut self, h: &mut Heap, stmt: BreakStatementId) -> VisitorResult {
         let the_while;
         if let Some(label) = h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal break: target not a while statement",
                 ));
+            }
             the_while = target.as_while();
         // TODO: check if break is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal break: no surrounding while statement",
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // break is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal break: synchronous statement escape",
             ));
+        }
         h[stmt].target = the_while.next;
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         h: &mut Heap,
         stmt: ContinueStatementId,
     ) -> VisitorResult {
         let the_while;
         if let Some(label) = h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal continue: target not a while statement",
                 ));
+            }
             the_while = target.as_while();
         // TODO: check if continue is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal continue: no surrounding while statement",
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // continue is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal continue: synchronous statement escape",
             ));
+        }
         h[stmt].target = Some(the_while.this);
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_goto_statement(&mut self, h: &mut Heap, stmt: GotoStatementId) -> VisitorResult {
         let target = self.get_target(h, h[stmt].label)?;
         if h[target].in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal goto: synchronous statement escape",
             ));
+        }
         h[stmt].target = Some(target);
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct AssignableExpressions {
     assignable: bool,
+}
 impl AssignableExpressions {
     fn new() -> Self {
         AssignableExpressions { assignable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unassignable expression"))
+    }
+}
 impl Visitor for AssignableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             self.assignable = true;
             self.visit_expression(h, h[expr].left)?;
             self.assignable = false;
             self.visit_expression(h, h[expr].right)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_conditional_expression(self, h, expr)
+        }
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             match h[expr].operation {
                 UnaryOperation::PostDecrement
                 | UnaryOperation::PreDecrement
                 | UnaryOperation::PostIncrement
                 | UnaryOperation::PreIncrement => {
                     self.assignable = true;
                     recursive_unary_expression(self, h, expr)?;
                     self.assignable = false;
                     Ok(())
+                }
                 _ => recursive_unary_expression(self, h, expr),
+            }
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.assignable;
         self.assignable = false;
         recursive_indexing_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.assignable;
         self.assignable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         if h[expr].field.is_length() && self.assignable {
             return self.error(h[expr].position);
+        }
         let old = self.assignable;
         self.assignable = false;
         recursive_select_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_array_expression(self, h, expr)
+        }
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_call_expression(self, h, expr)
+        }
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
     fn visit_variable_expression(
         &mut self,
         h: &mut Heap,
         expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 struct IndexableExpressions {
     indexable: bool,
+}
 impl IndexableExpressions {
     fn new() -> Self {
         IndexableExpressions { indexable: false }
+    }
     fn new() -> Self {  IndexableExpressions { indexable: false }  }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unindexable expression"))
+    }
+}
 impl Visitor for IndexableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             recursive_assignment_expression(self, h, expr)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         self.visit_expression(h, h[expr].test)?;
         self.indexable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.indexable && h[expr].operation != BinaryOperator::Concatenate {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
-        self.indexable = false;
+        self.indexable = true;
         self.visit_expression(h, h[expr].subject)?;
         self.indexable = false;
         self.visit_expression(h, h[expr].index)?;
         self.indexable = old;
-        self.visit_expression(h, h[expr].index)
+        Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = true;
         self.visit_expression(h, h[expr].subject)?;
         self.indexable = false;
         self.visit_expression(h, h[expr].from_index)?;
         self.visit_expression(h, h[expr].to_index)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_select_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_array_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_call_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
+}
 struct SelectableExpressions {
     selectable: bool,
+}
 impl SelectableExpressions {
     fn new() -> Self {
         SelectableExpressions { selectable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unselectable expression"))
+    }
+}
 impl Visitor for SelectableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         // left-hand side of assignment can be skipped
         let old = self.selectable;
         self.selectable = false;
         self.visit_expression(h, h[expr].right)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         self.visit_expression(h, h[expr].test)?;
         self.selectable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.selectable && h[expr].operation != BinaryOperator::Concatenate {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.selectable {
             self.error(h[expr].position)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_indexing_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_select_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_array_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_call_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.selectable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
+}
 pub struct Parser<'a> {
     source: &'a mut InputSource,
+}
 impl<'a> Parser<'a> {
     pub fn new(source: &'a mut InputSource) -> Self {
         Parser { source }
+    }
     pub fn parse(&mut self, h: &mut Heap) -> Result<RootId, ParseError> {
         let mut lex = Lexer::new(self.source);
         let pd = lex.consume_protocol_description(h)?;
         NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         LinkCallExpressions::new().visit_protocol_description(h, pd)?;
         BuildScope::new().visit_protocol_description(h, pd)?;
         ResolveVariables::new().visit_protocol_description(h, pd)?;
         LinkStatements::new().visit_protocol_description(h, pd)?;
         BuildLabels::new().visit_protocol_description(h, pd)?;
         ResolveLabels::new().visit_protocol_description(h, pd)?;
         AssignableExpressions::new().visit_protocol_description(h, pd)?;
         IndexableExpressions::new().visit_protocol_description(h, pd)?;
         SelectableExpressions::new().visit_protocol_description(h, pd)?;
         Ok(pd)
+    }
+}
 #[cfg(test)]
 mod tests {
     extern crate test_generator;
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use test_generator::test_resources;
     use super::*;
     #[test_resources("testdata/parser/positive/*.pdl")]
     fn batch1(resource: &str) {
         let path = Path::new(resource);
         let mut heap = Heap::new();
         let mut source = InputSource::from_file(&path).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(_) => {}
             Err(err) => {
                 println!("{}", err.display(&source));
                 println!("{:?}", err);
                 assert!(false);
+            }
+        }
+    }
     #[test_resources("testdata/parser/negative/*.pdl")]
     fn batch2(resource: &str) {
         let path = Path::new(resource);
         let expect = path.with_extension("txt");
         let mut heap = Heap::new();
         let mut source = InputSource::from_file(&path).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(pd) => {
                 println!("{:?}", heap[pd]);
                 println!("Expected parse error:");
                 let mut cev: Vec<u8> = Vec::new();
                 let mut f = File::open(expect).unwrap();
                 f.read_to_end(&mut cev).unwrap();
                 println!("{}", String::from_utf8_lossy(&cev));
                 assert!(false);
+            }
             Err(err) => {
                 println!("{:?}", err);
                 let mut vec: Vec<u8> = Vec::new();
                 err.write(&source, &mut vec).unwrap();
                 println!("{}", String::from_utf8_lossy(&vec));
                 let mut cev: Vec<u8> = Vec::new();
                 let mut f = File::open(expect).unwrap();
                 f.read_to_end(&mut cev).unwrap();
                 println!("{}", String::from_utf8_lossy(&cev));
                 assert_eq!(vec, cev);
+            }
+        }
+    }
+}

testdata/parser/negative/20.txt

➞

Show inline comments

deleted file

testdata/parser/positive/20.pdl

➞

Show inline comments

file renamed from testdata/parser/negative/20.pdl to testdata/parser/positive/20.pdl

0 comments (0 inline, 0 general)