class BrokenLet {
  test(): Int {{
    let a:Int<- in ;
    0;
    let let b: Int <- 1 in b;
    0;
    let C <- 1 in d;
    0;
    let a: Int <- 2, b: Int <- 5//7 in a+b;
    0;
    -- almost correct...
    (**)let(**)a(**):(**)Int(**)<-(**)2(**)in(**)A(**);
  }};
};

class BrokenCase {
  ouch(): Bool {{
    -- Screams when it sees the '+'
    if isvoid isvoid isvoid isvoid isvoid isvoid + 5 then true else false fi;
    0; -- <- Needed right now since IF doesn't yet recover properly

    case NotAnObjectID of
    already: Int => 0;
    broken: Int => 0;
    esac;
    
    case a of -- good so far
    WrongAgain: Int => 42;
    esac;

    case a of
    stillOK: now_it_breaks => 43;
    esac;

    case a of
    ok: Int => also_ok -- missing semicolon
    esac;

    case a of
    weird: Object =>
      case weird of
      weirder: Object =>
        case weirder of
        whoever_wrote_this_should_go_back_to_cs101: Int => 250;
        but_it_is_just_a_test: String => "Still legal so far";
        esac;
      esac;
    strange: Bool; -- missing some stuff
    esac;

    0; -- ok again
    :; -- make sure we see this one
  }};
};

class BrokenParens {
  t(): Int {
    (5+(3*7)-(28+42-~18))*9
    ) -- one too many!
  };

  t2(): Int {
   (5+(3*7)-(28+42-~18)*9 -- one too few!
  };
};

class BrokenFunction {
  t(): Int {
    illegal(): String {
      -- no nested functions please (panics at colon)
      "harhar"
    }
  };
};

class BrokenExprList {
  t(): Int {

    -- Here, only a single expression is allowed (no semicolon-terminated
    -- lists), because we would have to use an extra {} pair

    5+3; -- panics here.  this currently never recovers
    8-5;
    "illegal".length()*38;
  };
};