Might have added everything back.

7 files changed, 233 insertions, 65 deletions

diff --git a/src/core/src/tonkadur/fate/v1/lang/Sequence.java b/src/core/src/tonkadur/fate/v1/lang/Sequence.java
index f475b9d..5356cba 100644
--- a/src/core/src/tonkadur/fate/v1/lang/Sequence.java
+++ b/src/core/src/tonkadur/fate/v1/lang/Sequence.java
@@ -20,6 +20,7 @@ import tonkadur.fate.v1.error.IncomparableTypeException;
 import tonkadur.fate.v1.lang.meta.DeclaredEntity;
 import tonkadur.fate.v1.lang.meta.Instruction;
 import tonkadur.fate.v1.lang.meta.Computation;
+import tonkadur.fate.v1.lang.meta.RecurrentChecks;
 
 import tonkadur.fate.v1.lang.type.Type;
 
@@ -114,11 +115,16 @@ public class Sequence extends DeclaredEntity
 
       while (param_it.hasNext())
       {
+         final Computation param;
          final Type param_type, sign_type;
 
-         param_type = param_it.next().get_type();
+         param = param_it.next();
          sign_type = sign_it.next().get_type();
 
+         RecurrentChecks.handle_expected_type_propagation(param, sign_type);
+
+         param_type = param.get_type();
+
          if (param_type.can_be_used_as(sign_type))
          {
             continue;
diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/generic/IndexedPartitionComputation.java b/src/core/src/tonkadur/fate/v1/lang/computation/generic/IndexedPartitionComputation.java
index f09ba2a..ebe7b2b 100644
--- a/src/core/src/tonkadur/fate/v1/lang/computation/generic/IndexedPartitionComputation.java
+++ b/src/core/src/tonkadur/fate/v1/lang/computation/generic/IndexedPartitionComputation.java
@@ -103,7 +103,6 @@ public class IndexedPartitionComputation extends GenericComputation
             "auto generated"
          );
 
-
       return
          new IndexedPartitionComputation
          (
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableCall.java b/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableCall.java
index 285ed81..3a4ccb0 100644
--- a/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableCall.java
+++ b/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableCall.java
@@ -69,42 +69,24 @@ public class SequenceVariableCall extends GenericInstruction
    )
    throws Throwable
    {
-      // TODO: implement
-      // Quite a troublesome one, since we need to handle:
-      // * If first argument is a string, this is a reference to a sequence.
-      // * In that case, the expected type of each other parameter is to be
-      //   determined in the future.
-      final Computation sequence = null;
-      final List<Computation> parameters = null;
-      final List<Type> signature;
-
-      sequence.expect_non_string();
-
-      // TODO: change this system, since we'd rather use the signature to tell
-      // the parameters what to expect.
-      ((SequenceType) sequence.get_type()).propose_signature_from_parameters
-      (
-         parameters
-      );
+      final Computation sequence;
+      final List<Computation> parameters;
 
-      if (!sequence.get_type().get_act_as_type().equals(SequenceType.ARCHETYPE))
+      if (call_parameters.size() < 1)
       {
-         ErrorManager.handle
-         (
-            new InvalidTypeException
-            (
-               origin,
-               sequence.get_type(),
-               Collections.singleton(SequenceType.ARCHETYPE)
-            )
-         );
+         // TODO: Error.
+         System.err.println("Wrong number of params at " + origin.toString());
+
+         return null;
       }
 
-      RecurrentChecks.propagate_expected_types_and_assert_computations_matches_signature
+      sequence = call_parameters.get(0);
+      parameters = call_parameters.subList(1, call_parameters.size());
+
+      RecurrentChecks.propagate_expected_types_and_assert_is_sequence
       (
-         origin,
-         parameters,
-         ((SequenceType) sequence.get_type()).get_signature()
+         sequence,
+         parameters
       );
 
       return new SequenceVariableCall(origin, sequence, parameters);
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableJump.java b/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableJump.java
index ee09bef..66eef17 100644
--- a/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableJump.java
+++ b/src/core/src/tonkadur/fate/v1/lang/instruction/generic/SequenceVariableJump.java
@@ -120,43 +120,24 @@ public class SequenceVariableJump extends GenericInstruction
    )
    throws Throwable
    {
-      // TODO: implement
-      // Quite a troublesome one, since we need to handle:
-      // * If first argument is a string, this is a reference to a sequence.
-      // * In that case, the expected type of each other parameter is to be
-      //   determined in the future.
-      final Computation sequence = null;
-      final List<Computation> parameters = null;
+      final Computation sequence;
+      final List<Computation> parameters;
 
-      final List<Type> signature;
-
-      sequence.expect_non_string();
-
-      // TODO: change this system, since we'd rather use the signature to tell
-      // the parameters what to expect.
-      ((SequenceType) sequence.get_type()).propose_signature_from_parameters
-      (
-         parameters
-      );
-
-      if (!sequence.get_type().get_act_as_type().equals(SequenceType.ARCHETYPE))
+      if (call_parameters.size() < 1)
       {
-         ErrorManager.handle
-         (
-            new InvalidTypeException
-            (
-               origin,
-               sequence.get_type(),
-               Collections.singleton(SequenceType.ARCHETYPE)
-            )
-         );
+         // TODO: Error.
+         System.err.println("Wrong number of params at " + origin.toString());
+
+         return null;
       }
 
-      RecurrentChecks.propagate_expected_types_and_assert_computations_matches_signature
+      sequence = call_parameters.get(0);
+      parameters = call_parameters.subList(1, call_parameters.size());
+
+      RecurrentChecks.propagate_expected_types_and_assert_is_sequence
       (
-         origin,
-         parameters,
-         ((SequenceType) sequence.get_type()).get_signature()
+         sequence,
+         parameters
       );
 
       return new SequenceVariableJump(origin, sequence, parameters);
diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java b/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java
index 3e3c721..36513bf 100644
--- a/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java
+++ b/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java
@@ -19,6 +19,7 @@ import tonkadur.fate.v1.error.IncorrectReturnTypeException;
 
 import tonkadur.fate.v1.lang.type.CollectionType;
 import tonkadur.fate.v1.lang.type.LambdaType;
+import tonkadur.fate.v1.lang.type.SequenceType;
 import tonkadur.fate.v1.lang.type.Type;
 
 public class RecurrentChecks
@@ -376,6 +377,54 @@ public class RecurrentChecks
       }
    }
 
+   public static void propagate_expected_types_and_assert_is_sequence
+   (
+      final Computation sequence,
+      final List<Computation> params
+   )
+   throws ParsingError
+   {
+      final List<Type> sequence_signature;
+      final int params_size;
+
+      sequence.expect_non_string();
+
+      assert_is_a_sequence(sequence);
+
+      sequence_signature = ((SequenceType) sequence.get_type()).get_signature();
+
+      params_size = params.size();
+
+      if (params_size != sequence_signature.size())
+      {
+         ErrorManager.handle
+         (
+            new InvalidArityException
+            (
+               sequence.get_origin(),
+               params_size,
+               sequence_signature.size(),
+               sequence_signature.size()
+            )
+         );
+      }
+
+      for (int i = 0; i < params_size; ++i)
+      {
+         handle_expected_type_propagation
+         (
+            params.get(i),
+            sequence_signature.get(i)
+         );
+
+         assert_can_be_used_as
+         (
+            params.get(i),
+            sequence_signature.get(i)
+         );
+      }
+   }
+
    public static void propagate_expected_types_and_assert_is_lambda
    (
       final Computation lambda,
@@ -416,6 +465,12 @@ public class RecurrentChecks
             extra_params.get(j),
             lambda_signature.get(i)
          );
+
+         assert_can_be_used_as
+         (
+            extra_params.get(j),
+            lambda_signature.get(i)
+         );
       }
    }
 
@@ -541,6 +596,23 @@ public class RecurrentChecks
       }
    }
 
+   public static void assert_is_a_sequence (final Computation l)
+   throws ParsingError
+   {
+      if (!(l.get_type() instanceof SequenceType))
+      {
+         ErrorManager.handle
+         (
+            new InvalidTypeException
+            (
+               l.get_origin(),
+               l.get_type(),
+               Collections.singleton(SequenceType.ARCHETYPE)
+            )
+         );
+      }
+   }
+
    public static void assert_return_type_is
    (
       final Computation l,
diff --git a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
index 0cbe9f5..4c6a5d4 100644
--- a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
+++ b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4
@@ -53,7 +53,32 @@ INCLUDE_KW: L_PAREN 'include' SEP+;
 
 DECLARE_LOCAL_VARIABLE_KW: L_PAREN 'local' SEP+;
 
+VISIT_KW:
+   L_PAREN
+   (
+      ('call'|'visit') US ((('seq'|'Seq')'uence'?)|('proc'|'Proc')'edure'?)?
+   )
+   IMP;
 
+CONTINUE_AS_KW:
+   L_PAREN
+   (
+      (
+         'jump'
+         | ('jump' US 'to')
+         | ('jumpTo')
+         | ('continue' US 'as')
+         | ('continueAs')
+         | ('continue' US 'to')
+         | ('continueTo')
+         | ('continue' US 'with')
+         | ('continueWith')
+         | ('go' US 'to')
+         | ('goTo')
+      )
+      (US ((('seq'|'Seq')'uence'?)|('proc'|'Proc')'edure'?))?
+   )
+   IMP;
 
 
 VARIABLE_KW: L_PAREN ('variable'|'var') SEP+;
diff --git a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
index 7a1f546..80e1213 100644
--- a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
+++ b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4
@@ -921,6 +921,109 @@ returns [Instruction result]
    }
 
 /******************************************************************************/
+/**** SEQUENCE CALL/JUMP ******************************************************/
+/******************************************************************************/
+   | VISIT_KW computation maybe_computation_list WS* R_PAREN
+   {
+      final Origin origin;
+      final Computation sequence;
+
+      sequence = ($computation.result);
+      origin =
+         PARSER.get_origin_at
+         (
+            ($VISIT_KW.getLine()),
+            ($VISIT_KW.getCharPositionInLine())
+         );
+
+      sequence.expect_string();
+
+      if (sequence instanceof AmbiguousWord)
+      {
+         final String sequence_name;
+
+         sequence_name = ((AmbiguousWord) sequence).get_value_as_string();
+
+         PARSER.get_world().add_sequence_use
+         (
+            origin,
+            sequence_name,
+            ($maybe_computation_list.result)
+         );
+
+         $result =
+            new SequenceCall
+            (
+               origin,
+               sequence_name,
+               ($maybe_computation_list.result)
+            );
+      }
+      else
+      {
+         $result =
+            GenericInstruction.build
+            (
+               origin,
+               ($VISIT_KW.text).substring(0, (($VISIT_KW.text).length() - 1)),
+               ($maybe_computation_list.result)
+            );
+      }
+   }
+
+   | CONTINUE_AS_KW computation maybe_computation_list WS* R_PAREN
+   {
+      final Origin origin;
+      final Computation sequence;
+
+      sequence = ($computation.result);
+      origin =
+         PARSER.get_origin_at
+         (
+            ($CONTINUE_AS_KW.getLine()),
+            ($CONTINUE_AS_KW.getCharPositionInLine())
+         );
+
+      sequence.expect_string();
+
+      if (sequence instanceof AmbiguousWord)
+      {
+         final String sequence_name;
+
+         sequence_name = ((AmbiguousWord) sequence).get_value_as_string();
+
+         PARSER.get_world().add_sequence_use
+         (
+            origin,
+            sequence_name,
+            ($maybe_computation_list.result)
+         );
+
+         $result =
+            new SequenceJump
+            (
+               origin,
+               sequence_name,
+               ($maybe_computation_list.result)
+            );
+      }
+      else
+      {
+         $result =
+            GenericInstruction.build
+            (
+               origin,
+               ($CONTINUE_AS_KW.text).substring
+               (
+                  0,
+                  (($CONTINUE_AS_KW.text).length() - 1)
+               ),
+               ($maybe_computation_list.result)
+            );
+      }
+   }
+
+/******************************************************************************/
 /**** GENERIC INSTRUCTIONS ****************************************************/
 /******************************************************************************/
    | L_PAREN WORD maybe_computation_list WS* R_PAREN