Restructuring the compiler with intermediate data structures

src/algebra_ast.js

@@ -0,0 +1,36 @@
+const seq = (...args) => ({
+  toAlgebra: () => args.map(optimizeStep).map(toAlgebra).filter(nonEmptyExpressions).join('.')
+})
+
+const parallel = (...args) => ({
+  type: 'parallel',
+  args: args,
+  optimize: () => {
+    const parallelArgs = args.filter(arg => arg.type === 'parallel')
+    if (parallelArgs.length === args.length) {
+      return parallel(...parallelArgs.map(arg => arg.args).reduce((arr, a) => arr.concat(a), []))
+    }
+    return parallel(...args)
+  },
+  toAlgebra: () => {
+    let parallelPrograms = args.map(optimizeStep).map(toAlgebra).filter(nonEmptyExpressions)
+    if (parallelPrograms.length > 1) {
+      return `(${parallelPrograms.join('|')})`
+    }
+
+    return parallelPrograms.join('|')
+  }
+
+})
+
+const ambient = (name, ...args) => ({
+  toAlgebra: () => {
+    return `${name}[${args.map(optimizeStep).map(toAlgebra).filter(nonEmptyExpressions).join('|')}]`
+  }
+})
+
+const optimizeStep = node => node.optimize === undefined ? node : node.optimize()
+const toAlgebra = node => node.toAlgebra === undefined ? node.toString() : node.toAlgebra()
+const nonEmptyExpressions = string => string.length > 0
+
+module.exports = {ambient, seq, parallel}

src/ambients_ast.js

@@ -0,0 +1,130 @@
+const { literal, verifyPrimitive } = require('./primitives.js')
+const { ambient, seq, parallel } = require('./algebra_ast.js')
+
+const parameterDeclaration = (name) => ({
+  toAmbient: (scope) => {
+    return ambient(name, 'in_ arg.open arg.open_')
+  }
+})
+const variableExpression = (name) => ({
+  toAmbient: (scope) => {
+    return `open ${name}`
+  }
+})
+const binaryExpression = (left, right, operator) => {
+  let primitive = verifyPrimitive(left, right)
+  switch (operator) {
+    case '+':
+      return primitive.plus(left, right)
+    case '*':
+      return primitive.multiply(left, right)
+    default:
+      throw new Error(`Operator '${operator}' is not supported`)
+  }
+
+}
+
+const callExpression = (functionName) => ({
+  toAmbient: (scope) => {
+    return scope.functionCall(functionName)
+  }
+})
+
+const funcEnvelope = (expression) => ({
+  toAmbient: (scope) => {
+    return ambient('func',
+      expression.toAmbient(scope),
+      'open_')
+  }
+})
+
+const functionExpression = (args, expression) => ({
+  toAmbient: (scope) => {
+    return parallel(
+      scope.functionArgs(args),
+      expression.toAmbient(scope))
+  }
+})
+
+const functionDefinition = (name, body) => ({
+  toAmbient: (scope) => {
+    let newScope = scope.newScope(name)
+    return ambient(name,
+      newScope.capabilities(),
+      seq('in_ call.open call', parallel(
+        body.toAmbient(newScope),
+        'open return.open_'
+      ))
+    )
+  }
+})
+
+const programFile = (declarations, resultStatement) => ({
+  toAmbient: (scope) => {
+    const algebra = declarations
+      .map(declaration => declaration.toAmbient(scope).toAlgebra())
+      .map(code => code.replace(/\r?\n\s*|\r\s*/g, '').replace(/\s+/g, ' '))
+      .join('|')
+    return algebra
+  }
+})
+
+class Scope {
+  constructor (name, parentScope) {
+    this._name = name
+    this._parentScope = parentScope
+    this._auths = []
+  }
+
+  functionArgs (args) {
+    return parallel(...args.map(arg => arg.toAmbient(this)))
+  }
+
+  functionCall (functionName) {
+    let scopesToPass = this.allow('call', functionName)
+    let outCalls = scopesToPass.map(x => `out ${x}.`)
+    let inReturns = scopesToPass.reverse().map(x => `in ${x}.`)
+
+    return parallel(
+      ambient('call',
+        seq(`${outCalls}in ${functionName}.open_`,
+          ambient('return', `open_.${inReturns}in func`))),
+      ambient('func',
+        seq(`in_ ${functionName}.open ${functionName}.open_`)),
+      'open func')
+  }
+
+  newScope (name) {
+    return new Scope(name, this)
+  }
+
+  capabilities () {
+    return {
+      toAlgebra: () => {
+        return this._auths.map((auth) => `out_ ${auth.exit}.in_ ${auth.enter}`).join('|')
+      }
+    }
+  }
+
+  allow (exit, enter) {
+    if (this._parentScope === undefined) {
+      return []
+    }
+    this._auths.push({ exit: exit, enter: enter })
+    return [this._name].concat(this._parentScope.allow(exit, enter))
+  }
+}
+
+module.exports = {
+  Scope,
+  literal,
+  binaryExpression,
+  functionExpression,
+  functionDefinition,
+  programFile,
+  callExpression,
+  parameterDeclaration,
+  variableExpression,
+  funcEnvelope
+
+}

src/esprima_ast_mapper.js

@@ -0,0 +1,31 @@
+const esprima = require('esprima')
+
+const astMapper = () => ({
+  mappers: {},
+  match: function (nodetype, func) {
+    this.mappers[nodetype] = func
+  },
+  parse: function (node, context) {
+    if (Array.isArray(node)) {
+      return node
+        .map((n) => this.parse(n, context))
+        .filter(x => x)
+        .reduce((acc, x) => acc.concat(x), [])
+    }
+    let mappingFunc = this.mappers[node.type]
+    if (mappingFunc === undefined)
+      return undefined
+
+    return mappingFunc(node, context)
+  },
+  parseAndMap: function (js) {
+    let counter = 0
+    let esprimaMapper = (node, meta) => {
+      console.log(`${++counter}: ${node.type} (${js.substring(meta.start.offset, meta.end.offset)}) - (${Object.keys(node)})`)
+    }
+    return this.parse(esprima.parseScript(js, {}, esprimaMapper))
+  }
+})
+
+
+module.exports = astMapper