External trait attributes

Sources/AST/Declaration/TraitDeclaration.swift

@@ -14,20 +14,20 @@ public struct TraitDeclaration: ASTNode {
   public var identifier: Identifier
   // TODO: public var states: [TypeState]
   public var members: [TraitMember]
-  public var moduleAddress: String? // Move-specific
+  public var decorators: [FunctionCall] // Move-specific
 
   public init(
     traitKind: Token,
     traitToken: Token,
     identifier: Identifier,
     members: [TraitMember],
-    moduleAddress: String? = nil
+    decorators: [FunctionCall] = []
   ) {
     self.traitKind = traitKind
     self.traitToken = traitToken
     self.identifier = identifier
     self.members = members
-    self.moduleAddress = moduleAddress
+    self.decorators = decorators
   }
 
   // MARK: - ASTNode

Sources/AST/Environment/Environment+Additions.swift

@@ -263,6 +263,9 @@ extension Environment {
       let special = externalTraitInitializer(trait)
       addInitializerSignature(special, enclosingType: trait.identifier.name, callerProtections: [],
                               generated: true)
+      if !trait.decorators.isEmpty {
+        types[trait.identifier.name]?.decorators = trait.decorators
+      }
     } else {
       isExternal = false
     }

Sources/AST/Environment/Information/CallableInformation.swift

@@ -10,7 +10,7 @@ public enum CallableInformation {
   case functionInformation(FunctionInformation)
   case specialInformation(SpecialInformation)
 
-  var parameterTypes: [RawType] {
+  public var parameterTypes: [RawType] {
     switch self {
     case .functionInformation(let functionInformation):
       return functionInformation.parameterTypes

Sources/AST/Environment/Information/TypeInformation.swift

@@ -16,6 +16,7 @@ public struct TypeInformation {
   public var publicInitializer: SpecialDeclaration?
   var publicFallback: SpecialDeclaration?
   var conformances: [TypeInformation] = []
+  public var decorators: [FunctionCall]?
 
   public var allFunctions: [String: [FunctionInformation]] {
     return conformances.map({ $0.functions }).reduce(functions, +)

Sources/Compiler/Compiler.swift

@@ -765,6 +765,16 @@ public enum CompilerTarget {
     case .move: return "mvir"
     }
   }
+
+  public func configureSemanticAnalyser(semanticAnalyser: SemanticAnalyzer) -> SemanticAnalyzer {
+    switch self {
+    case .evm: return semanticAnalyser
+    case .move:
+      var semanticAnalyser = semanticAnalyser
+      semanticAnalyser.allowExternalStructs = true
+      return semanticAnalyser
+    }
+  }
 }
 
 public struct CompilerConfiguration {
@@ -813,8 +823,14 @@ public struct CompilerConfiguration {
     self.maxTransactionDepth = maxTransactionDepth
     self.skipVerifier = skipVerifier
     self.skipCodeGen = skipCodeGen
-    self.diagnostics = diagnostics
-    self.astPasses = astPasses ?? (Compiler.defaultASTPasses + (skipVerifier ? [] : Compiler.verifierASTPasses))
+    self.diagnostics = diagnostics //Compiler.defaultASTPasses
+    self.astPasses = (astPasses ?? (Compiler.defaultASTPasses + (skipVerifier ? [] : Compiler.verifierASTPasses)))
+        .map { (pass: ASTPass) in
+      if let pass = pass as? SemanticAnalyzer {
+        return target.configureSemanticAnalyser(semanticAnalyser: pass)
+      }
+      return pass
+    }
     self.stdLib = stdLib
     self.target = target
   }

Sources/Compiler/Target.swift

@@ -96,7 +96,10 @@ public class MoveTarget: Target {
       }
       exit(0)
     }
-    let generator = MoveGenerator(ast: irPreprocessOutcome.element, environment: environment)
+
+    let generator = MoveGenerator(ast: irPreprocessOutcome.element,
+                                  environment: environment,
+                                  sourceContext: sourceContext)
     return generator.generateCode()
   }
 }

Sources/MoveGen/AST/FunctionDeclaration.swift

@@ -120,7 +120,7 @@ extension AST.FunctionDeclaration {
     }
 
     let args: [FunctionArgument] = signature.parameters.map { parameter in
-      return FunctionArgument(.identifier(parameter.identifier))
+      FunctionArgument(.identifier(parameter.identifier))
     }
 
     let functionCallExpr: Expression = .functionCall(

Sources/MoveGen/AST/TraitDeclaration.swift

@@ -0,0 +1,37 @@
+//
+// Created by matthewross on 31/08/19.
+//
+
+import Foundation
+import AST
+
+extension TraitDeclaration {
+  var moduleAddress: String? {
+    guard let argument: FunctionArgument = decorators.first(where: { $0.identifier.name == "module" })?.arguments[0],
+          let name = argument.identifier?.name,
+          name == "address",
+          case .literal(let token) = argument.expression,
+          case .literal(.address(let address)) = token.kind else {
+      return nil
+    }
+    return address
+  }
+
+  var isModule: Bool {
+    return decorators.contains(where: { $0.identifier.name == "module" })
+  }
+
+  var associatedModule: String? {
+    guard let argument = decorators.first(where: { $0.identifier.name == "associated" })?.arguments[0],
+          let name = argument.identifier?.name,
+          name == "",
+          case .identifier(let identifier) = argument.expression else {
+      return nil
+    }
+    return identifier.name
+  }
+
+  var isStruct: Bool {
+    return decorators.contains(where: { $0.identifier.name == "data" })
+  }
+}

Sources/MoveGen/AST/Type.swift

@@ -8,15 +8,17 @@
 import AST
 
 extension RawType {
-  public func isExternalTraitType(environment: Environment) -> Bool {
+  public func isExternalContract(environment: Environment) -> Bool {
     var internalRawType: RawType = self
     while case .inoutType(let inoutType) = internalRawType {
       internalRawType = inoutType
     }
     if case .userDefinedType(let typeIdentifier) = internalRawType {
       return environment.isExternalTraitDeclared(typeIdentifier)
+          && !(environment.types[typeIdentifier].flatMap { (information: TypeInformation) in
+        information.decorators?.contains(where: { $0.identifier.name == "data" })
+      } ?? false)
     }
-
     return false
   }
 }

Sources/MoveGen/Component/MoveSelf.swift

@@ -10,6 +10,7 @@ import Lexer
 import MoveIR
 import Source
 import AST
+import Diagnostic
 
 /// Generates code for a "self" expression.
 struct MoveSelf {
@@ -32,14 +33,21 @@ struct MoveSelf {
       fatalError("Unexpected token \(token.kind)")
     }
     guard !functionContext.isConstructor else {
-      print(#"""
-            \#u{001B}[1;38;5;196mMoveIR generation error:\#u{001B}[0m \#
-            `self' reference before all fields initialized in function `init' in \#(token.sourceLocation)
-            \#tCannot use `self' in a constructor before all attributes have been assigned to, \#
-            as some are still unitialized. This includes any method calls which could access instance fields.
-            \#tInstead try moving method calls to after all values have been initialized.
-            """#)
-      exit(1)
+      Diagnostics.add(Diagnostic(severity: .error,
+                                 sourceLocation: token.sourceLocation,
+                                 message: "`self' reference before all fields initialized in function `init'"))
+      Diagnostics.add(Diagnostic(severity: .note,
+                                 sourceLocation: token.sourceLocation,
+                                 message: #"""
+                                          Cannot use `self' in a constructor before all \#
+                                          attributes have been assigned to, \#
+                                          as some are still unitialised. This includes any \#
+                                          method calls which could access instance fields. \#
+
+                                          Instead try moving method calls to after all values \#
+                                          have been initialized.
+                                          """#))
+      Diagnostics.displayAndExit()
     }
 
     if position == .left {

Sources/MoveGen/Declaration/MoveVariableDeclaration.swift

@@ -8,6 +8,7 @@
 import Foundation
 import AST
 import MoveIR
+import Diagnostic
 
 /// Generates code for a variable declaration.
 struct MoveVariableDeclaration {
@@ -18,15 +19,12 @@ struct MoveVariableDeclaration {
         from: variableDeclaration.type.rawType,
         environment: functionContext.environment
     )?.render(functionContext: functionContext) else {
-      print("""
-            Cannot get variable declaration type from \(variableDeclaration.type.rawType) \
-            at position \(variableDeclaration.sourceLocation) for variable \(variableDeclaration.identifier.name).
-
-            \(functionContext.blockStack)
-
-            flintc internal error located at \(#file):\(#line)
-            """)
-      exit(1)
+      Diagnostics.add(Diagnostic(
+          severity: .error,
+          sourceLocation: variableDeclaration.sourceLocation,
+          message: "Cannot get variable declaration type from \(variableDeclaration.type.rawType)"
+      ))
+      Diagnostics.displayAndExit()
     }
     guard !variableDeclaration.identifier.isSelf else {
       return .variableDeclaration(MoveIR.VariableDeclaration((MoveSelf.name, typeIR)))

Sources/MoveGen/Diagnostics/Diagnostics.swift

@@ -0,0 +1,21 @@
+import Diagnostic
+import Foundation
+
+class Diagnostics {
+  public static var diagnostics: [Diagnostic] = []
+  public static var sourceContext: SourceContext?
+
+  static func add(_ diagnostics: Diagnostic...) {
+    self.diagnostics.append(contentsOf: diagnostics)
+  }
+
+  static func display() {
+    try! print(DiagnosticsFormatter(diagnostics: diagnostics,
+                                    sourceContext: sourceContext!).rendered())
+  }
+
+  static func displayAndExit(code: Int32 = 1) -> Never {
+    display()
+    return exit(code)
+  }
+}