Fix typing for Binary, Unary, and Logical Expressions (#24)

* Add button for playground at Navbar

No functionality.

* Make first NavbarGroup's align left explicit

* Change playground icon

* Add routes to Playground

* Update test snapshots

* Fix bad test for Playground component

Oops

* Add react-ace for IDE

* Try passing props into playground

* Load a preset "Hello World" onto the ace editor.

Changes:
- Changed `Playground` component to a statefull one (extends `React.Component)
- add property `playgroundCode` to IApplicationState (bad practice,
change to a slice of the state instead)
- add interface `IPlaygroundProps` to denote the properties passed to
Playground

* Remove unused onChange()

* Add stored state for playground editor text

Once again, this is a WIP. Text typed into the playground editor will
stay in the playground (or rather, appear again) after leaving and
coming back.

Changes:
- added of action, actionCreator (updatePlaygroundCode)
- added a reducer under application's `reducer` function

Possible problems:
- Location of reducer
- Location of playgroundCode stored (as in previous commit)

* Change initialValue prop to editorValue

* Made playground actions a separate file

* Modify actions and dispatch call

* Change redux import statement

* Add IPlaygroundState to IState in index reducer

* Add playground reducer

* Remove playgroundCode from IApplicationState

* Fix type errors

Made a compromise by including an IPlaygroundState as part of IApplicationProps

* Re-disable console.logs (tslint)

* Fix missing imports for react-ace mode, theme

* Add playground CSS

* Add JSDoc style comments for playground

* Fix some tests

* Fix semantics of mapStateToProps for ApplicationContainer

* Do trivial formatting

* Add interpreter toolchain as 'slang'

This is a copy over of the current state of `./frontend/src/toolchain` at
source-academy/source-academy2 67d9184. It includes only source chapter 1, a new
specification (see [PR 6 at the
source-academy/source-academy2](source-academy/source-academy2#6)
repository).

* Add react-saga and react types to yarn

The react types were added as a result of the `yarn add` command.

* Add saga to middleware list

* Segregate actionTypes from actions

* Fix reducer actionType import

* Remove actionType import from action/index

* Fix fatal bug with defineVariable calls

* Fix missing imports

Some imports of slang are already provided as additional dependencies to other
modules, e.g. acorn is already a dependency of webpack

* Add tests for slang

* Remove unused type definitions

* Lint typescript files of slang

* Add interruption actionType

* Add sagas WIP

For ny's reference

* Add more interpreter actions

* Change to older version of saga

* Add notification file

* Change es target to es2016

This was the target in sourceacademy-2 as well. Without this, there was
a problem with casting an `IterableIterator` to `yield*`, that expected
an array.

* Revert "Remove unused type definitions"

This reverts commit e18f2ae.
"Oops" - @ningyuansg

* Fix some slang errors

* Make 16/05 code review changes

Changes not made:
- Change of `Playground` component to an `SFC`

* Fix test snapshot (name of onChange for ReactAce)

Due to 7ac707c.

* Revert Playground as SFC, make Editor container

* Make Playground stateless

This is done by abstracting out the ace editor into its own component
, `Editor`, and its own container to handle redux calls,
`EditorContainer`.

* Add test and fix export type

Export of `Editor` changed to a default export, like the other
components. A test has been added for the `Editor` component. Snapshot
changes pending.

* Fix type errors according to tslint

* Change object methods to use es6 shorthand

* Fix more linting errors for interpreter.ts

* Disable `no-empty` rule.

Rationale: A no-op function is much easier to see as `() => {}` as
compared to `() => undefined` or even `() =>`. In addition, this syntax
is used by parts of the interpreter as well.

* Add `max-classes-per-file` exception for interpreter files

Splitting the exports would cause futher refactoring in other parts of
the interpreter codebase

* Fix linting errors in parser, rules/braces...

* Fix tslint errors in `parser`

Exception was added for multiple class exports.

* Format interpreter.ts

* Fix tslint errors in rules/*

* Fix tslint errors for rttc.ts

* Fix tslint errors for node.ts

* Fix tslint errors for types.ts

* Fix stdlib/list, stdlib/misc and scheudler tslint

An additional change is the use of a line disable in `parser.ts` instead
of an entire file disable.

* Fix `saga` not being run after store creation

* Fix Editor test (tslint errors)

1. Missing comma in object props
2. Syntax error and missing object comprehension in creating Editor

* Add properties context, output to IPlaygroundState

1. context is of type slang.Context. This holds the 'environment' for the slang
   interpreter
2. Output is a string array that will hold the stdout/stderr (display, error
   calls) of a program run in the editor. For repl programs, it will also hold
   the return value of the program. Each element of an array is a historical
   output.

* Add button to call on handleEvalEditor

This change allows the newly added button to call upon the
handleEvalEditor callback, whose reducer is not defined (yet)

* Add mapDispatchToProps for EditorContainer

Note that the intersection type is used with `Pick<T>` in order to
define `DispatchProps`, this might not be ideal. Input on this issue
would be appreciated.

* Fix 'ace is undefined' error

* Add Output SFC

* Add output tests, did yarn format

* Add 'run' button to EditorContainer

* Change Editor snapshot to include button

* Wire saga interpreter success to output SFC

* Fix wrong file extension '.tsx' -> '.ts'

'Oops' - ny

* Move state definitions into their own file

Fixes #7

* Add type for interpreter outputs

In addition, tslint rule `interface-over-type-literal` was disabled, due to the need
for many types (that would not be extended)

* Fix #11, using bindActionCreators

* Add flexboxgrid dependency

* Line Editor and Output up side to side

* Refactor and modularise playground as IDE

* Change Output to Repl

This is to allow for the incoming repl, which will produce outputs as
well.

* Implement multiple Outputs in Repl (history)

* Fix class playground not taking up all of parent

* Make use of slang's toString to format values

Previously, undefined would print as '' (empty string).

* Make flexbox tags relative to current component

* Make IPlaygroundState properties readonly

Fixes #14

* Add ReplInput (not wired to saga)

* Replace TextArea with AceEditor

Also change theme to dark background so we can debug better.

* Move IDE buton to a separate Control component

This is contained within the IDE component

* Add property replValue to IPlaygroundState

replValue, like editorValue, will store the contents of repl. It is used to
allow the contents of the repl to persist through route changes. It is also the
target for evaluation.

* Make repl read from state.playground.replValue

* Add evalRepl

* Update Control snapshot with eval button

* Add action UPDATE_REPL_VALUE

* Implement persistent repl content across routes

* Did yarn format

* Add action clear repl

Also removed unnecessarily verbose typings

* Make eval button clear the replValue

* Fix repl context resetting every eval

TODO: Editor run needs to update playground context

* Add keyboard shortcut for REPL

* Fix formatting for repl shortcut

* Errors are loosely represented as string 'error'

* Fix yarn format git hooks passing for unformatted

Previously, if the staged files are not formatted according to prettier, running
the pre-commit hook would change the file formatting, and then return an exit
code 0, allowing the commit to go through. However, the changes made by prettier
are not staged.

Now, the pre-commit hook will fail, so that only prettier-passed files can be
committed.

* Add ParseError in slang

* Improve error messages to specify type of error

* Improve CSS for repl output

* Fix many error messages not printing on new lines

Thank you stackoverflow

* Fix editor not changing playground.context

* Change ParseError to a function, parseError

* Simplify REPL Output Component creation

Turns out there's a 2-arity `map` that provides index

* Rename playground css to ide

* Change Playground to IDE in ide.css

No visible change in effect. Regardless, this will probably be
refactored once SCSS is introduced

* Change "ClEAR_REPL" to "CLEAR_REPL_INPUT"

This is to differenciate between the clearing of repl input and output

* Add button and actions to clear REPL output

- Button added
- Action and reducer added

* Make the clear button wipe the REPL context

* Revert "Make clear button wipe the REPL context"

I realised that source academy does not clear the context, and that
clearing only the output is in line with most command-line applications
and REPLs.
This reverts commit 4bd3c44.

* Remove duplicate EditorContainer

Was received from merging master into the branch

* Fix button row in playground overflowing to right

Would cause tiny bit of empty space on the right of the page, slightly outside
the viewport.

* Make run button clearReplOutput, remove default

* Output code typed in ReplInput as Output

* Use array method concat, reorder definitions

Readability changes.

* No verify commit, tests fails

* Fix failing tests

Okay, so slang's display needs access to the store in order to call dispatch, so
that the display can be output'd in realtime. In the previous commit, this was
achieved by importing the instantiated store from src/index.tsx into
src/slang/stdlib/misc.ts.

This works when the full server is running, but fails with the tests, because
mockContext calls createContext, which imports stdlib/misc, which tries to
import store. But because it's just a test, and store doesn't exist, the test
fails.

* Make run button interrupt execution

* Make eval interrupt execution, remove notifs

Next, change display so that if playground.output array is empty, initialise.

* Fix display not working after a clear

* Fix Eval button crashing site when Output[] empty

This is because the Output SFC tries to access an undefined output.consoleLogs.

output.consoleLogs is undefined after an Eval button click, because
EVAL_INTERPRETER_(SUCCESS|ERRORS) will try to access the last element of
playground.outputs, but the last element after playground.outputs is always a
CodeOutput for Eval button presses; and CodeOutput doesn't have a consoleLogs
property, so EVAL_INTERPRETER_(SUCCESS|ERRORS) copies over undefined as the new
ResultOutput or ErrorOutput's consoleLog property.

* Refactor display interactions with react/redux

* Make RTTC errors fatal, add checks for unary

RTTC errors (type errors found at runtime) will now interrupt execution of the
program and return an error immediately.

Checks for unary expression arguments have been implemented.

* Update type rules for binary operators

Function type checks not yet implemented

* Fix typings not working for functions

* Fix typings for logical expressions

* Fix number + number raising error

* Fix number (<|<=|>|>=) number raising error

* Add tests, fix some errors with + operator

* Revert typing restrictions for === and !==

=== and !== no longer raises errors.

src/mocks/context.ts

@@ -1,6 +1,31 @@
 import { createContext } from '../slang'
-import { Context } from '../slang/types'
+import { Closure, Context } from '../slang/types'
 
 export function mockContext(chapter = 1): Context {
   return createContext(chapter)
 }
+
+export function mockRuntimeContext(): Context {
+  const context = createContext()
+  context.runtime = {
+    isRunning: true,
+    frames: [],
+    nodes: [
+      {
+        type: 'Literal',
+        loc: {
+          start: { line: 1, column: 0 },
+          end: { line: 1, column: 1 }
+        },
+        value: 0,
+        raw: '0',
+        range: [0, 1]
+      }
+    ]
+  }
+  return context
+}
+
+export function mockClosure(): Closure {
+  return {} as Closure
+}

src/slang/interop.ts

@@ -58,7 +58,7 @@ const arrayToString = (value: Value[], length: number) => {
 }
 
 export const toString = (value: Value, length = 0): string => {
-  if (value instanceof Closure) {
+  if (value instanceof ArrowClosure || value instanceof Closure) {
     return generate(value.node)
   } else if (Array.isArray(value)) {
     if (length > MAX_LIST_DISPLAY_LENGTH) {

src/slang/interpreter.ts

@@ -176,6 +176,13 @@ export const evaluators: { [nodeType: string]: Evaluator<es.Node> } = {
   },
   *UnaryExpression(node: es.UnaryExpression, context: Context) {
     const value = yield* evaluate(node.argument, context)
+
+    const error = rttc.checkUnaryExpression(context, node.operator, value)
+    if (error) {
+      handleError(context, error)
+      return undefined
+    }
+
     if (node.operator === '!') {
       return !value
     } else if (node.operator === '-') {
@@ -188,7 +195,11 @@ export const evaluators: { [nodeType: string]: Evaluator<es.Node> } = {
     const left = yield* evaluate(node.left, context)
     const right = yield* evaluate(node.right, context)
 
-    rttc.checkBinaryExpression(context, node.operator, left, right)
+    const error = rttc.checkBinaryExpression(context, node.operator, left, right)
+    if (error) {
+      handleError(context, error)
+      return undefined
+    }
 
     let result
     switch (node.operator) {
@@ -235,8 +246,20 @@ export const evaluators: { [nodeType: string]: Evaluator<es.Node> } = {
   },
   *LogicalExpression(node: es.LogicalExpression, context: Context) {
     const left = yield* evaluate(node.left, context)
-    if ((node.operator === '&&' && left) || (node.operator === '||' && !left)) {
-      return yield* evaluate(node.right, context)
+    let error = rttc.checkLogicalExpression(context, left, true)
+    if (error) {
+      handleError(context, error)
+      return undefined
+    } else if ((node.operator === '&&' && left) || (node.operator === '||' && !left)) {
+      // only evaluate right if required (lazy); but when we do, check typeof right
+      const right = yield* evaluate(node.right, context)
+      error = rttc.checkLogicalExpression(context, left, right)
+      if (error) {
+        handleError(context, error)
+        return undefined
+      } else {
+        return right
+      }
     } else {
       return left
     }

src/slang/utils/__tests__/rttc.ts

@@ -0,0 +1,175 @@
+import { BinaryOperator, UnaryOperator } from 'estree'
+import { mockClosure, mockRuntimeContext } from '../../../mocks/context'
+import { checkBinaryExpression, checkLogicalExpression, checkUnaryExpression } from '../rttc'
+
+const num = 0
+const bool = true
+const str = ' '
+const func = mockClosure()
+
+test('Valid unary type combinations are OK', () => {
+  const operatorValue = [['!', bool], ['+', num], ['-', num]]
+  const context = mockRuntimeContext()
+  const errors = operatorValue.map(opVals => {
+    return checkUnaryExpression(context, opVals[0] as UnaryOperator, opVals[1])
+  })
+  errors.map(error => expect(error).toBe(undefined))
+})
+
+test('Invalid unary type combinations return TypeError', () => {
+  const operatorValue = [
+    ['!', num],
+    ['!', str],
+    ['!', func],
+    ['+', bool],
+    ['+', str],
+    ['+', func],
+    ['-', bool],
+    ['-', str],
+    ['-', func]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValue.map(opVals => {
+    return checkUnaryExpression(context, opVals[0] as UnaryOperator, opVals[1])
+  })
+  errors.map(error => expect(error).toBeDefined())
+})
+
+test('Valid binary type combinations are OK for +', () => {
+  const operatorValues = [
+    ['+', num, num],
+    ['+', str, num],
+    ['+', str, bool],
+    ['+', str, func],
+    ['+', num, str],
+    ['+', bool, str],
+    ['+', func, str]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkBinaryExpression(context, opVals[0] as BinaryOperator, opVals[1], opVals[2])
+  })
+  errors.map(error => expect(error).toBe(undefined))
+})
+
+test('Invalid binary type combinations for (-|*|/|%) return TypeError', () => {
+  const operatorValues = [
+    ['-', num, bool],
+    ['-', num, str],
+    ['-', num, func],
+    ['-', bool, num],
+    ['-', str, num],
+    ['-', func, num],
+    ['-', str, bool],
+    ['-', str, func],
+    ['-', bool, bool],
+    ['-', str, str],
+    ['-', func, func],
+    ['*', num, bool],
+    ['*', num, str],
+    ['*', num, func],
+    ['*', bool, num],
+    ['*', str, num],
+    ['*', func, num],
+    ['*', str, bool],
+    ['*', str, func],
+    ['*', bool, bool],
+    ['*', str, str],
+    ['*', func, func],
+    ['/', num, bool],
+    ['/', num, str],
+    ['/', num, func],
+    ['/', bool, num],
+    ['/', str, num],
+    ['/', func, num],
+    ['/', str, bool],
+    ['/', str, func],
+    ['/', bool, bool],
+    ['/', str, str],
+    ['/', func, func],
+    ['%', num, bool],
+    ['%', num, str],
+    ['%', num, func],
+    ['%', bool, num],
+    ['%', str, num],
+    ['%', func, num],
+    ['%', str, bool],
+    ['%', str, func],
+    ['%', bool, bool],
+    ['%', str, str],
+    ['%', func, func]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkBinaryExpression(context, opVals[0] as BinaryOperator, opVals[1], opVals[2])
+  })
+  errors.map(error => expect(error).toBeDefined())
+})
+
+test('Valid binary type combinations are OK for (===|!==)', () => {
+  const operatorValues = [
+    ['===', num, num],
+    ['===', bool, bool],
+    ['===', str, str],
+    ['===', func, func],
+    ['!==', num, num],
+    ['!==', bool, bool],
+    ['!==', str, str],
+    ['!==', func, func]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkBinaryExpression(context, opVals[0] as BinaryOperator, opVals[1], opVals[2])
+  })
+  errors.map(error => expect(error).toBe(undefined))
+})
+
+test('Invalid binary type combinations for (<|>|<==|>==) return TypeError', () => {
+  const operatorValues = [
+    ['<', bool, num],
+    ['<', str, num],
+    ['<', str, func],
+    ['<', num, str],
+    ['>', func, num],
+    ['>', bool, num],
+    ['>', func, bool],
+    ['>', str, func],
+    ['<=', str, num],
+    ['<=', func, func],
+    ['<=', num, str],
+    ['<=', bool, bool],
+    ['>=', func, num],
+    ['>=', str, func]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkBinaryExpression(context, opVals[0] as BinaryOperator, opVals[1], opVals[2])
+  })
+  errors.map(error => expect(error).toBeDefined())
+})
+
+test('Valid logical type combinations are OK', () => {
+  const operatorValues = [[bool, bool], [bool, bool]]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkLogicalExpression(context, opVals[0], opVals[1])
+  })
+  errors.map(error => expect(error).toBe(undefined))
+})
+
+test('Invalid logical type combinations return TypeError', () => {
+  const operatorValues = [
+    [num, bool],
+    [bool, num],
+    [func, bool],
+    [bool, func],
+    [func, func],
+    [num, num],
+    [str, str]
+  ]
+  const context = mockRuntimeContext()
+  const errors = operatorValues.map(opVals => {
+    return checkLogicalExpression(context, opVals[0], opVals[1])
+  })
+  errors.map(error => expect(error).toBeDefined())
+})