Add module parsing

regression-tests/tests/import-styling-expr.out

@@ -0,0 +1 @@
+

regression-tests/tests/import-styling-expr.ssl

@@ -0,0 +1,14 @@
+import Foo
+import Example.Module as Baz
+import Another.Example with { 
+                    x,
+                    y as z
+}
+
+main cin cout =
+  let one = Foo.Bar
+  let two = Baz.a
+  let three = Another.Example.z
+
+  after 1, cout <- 10
+  wait cout

regression-tests/tests/import-styling.out

@@ -0,0 +1 @@
+

regression-tests/tests/import-styling.ssl

@@ -0,0 +1,16 @@
+import Foo
+
+import Foo.Bar
+
+import Foo.Bar.Baz as Baz
+
+import Foo.Bar.Baz with doo, bar
+
+import Foo.Bar.Baz with { 
+                    foo,
+                    bar as baz
+}
+
+main cin cout =
+  after 1, cout <- 10
+  wait cout

src/Front/Ast.hs

@@ -21,8 +21,21 @@ data TopDef
   | TopType TypeDef       -- ^ Define an algebraic data type
   | TopCDefs String       -- ^ Inlined block of C definitions
   | TopExtern ExternDecl  -- ^ Declare external symbol for FFI
+  | TopImport Import   -- ^ Top Level import statement
   deriving (Eq, Show, Typeable, Data)
 
+data Import =
+     ImportSym [Identifier]
+   | ImportAs [Identifier] Identifier
+   | ImportWith [Identifier] [ImportElement]
+  deriving (Eq, Show, Typeable, Data)
+
+
+data ImportElement
+  = ElementAs Identifier Identifier
+  | ElementSymbol Identifier
+ deriving (Eq, Show, Typeable, Data)
+
 -- | Associate a type with a symbol
 data ExternDecl = ExternDecl Identifier Typ
   deriving (Eq, Show, Typeable, Data)
@@ -99,6 +112,7 @@ data Expr
   | CCall Identifier [Expr]
   | Tuple [Expr]
   | ListExpr [Expr]
+  | ImportId [Identifier]
   deriving (Eq, Show, Typeable, Data)
 
 {- | An operator region: a flat list of alternating expressions and operators
@@ -196,6 +210,17 @@ instance Pretty TopDef where
   pretty (TopType   t ) = pretty t
   pretty (TopCDefs  ds) = pretty "$$" <> pretty ds <> pretty "$$"
   pretty (TopExtern x ) = pretty x
+  pretty (TopImport i) = pretty i
+
+instance Pretty Import where
+	pretty (ImportSym is) = hsep (map pretty is)
+	pretty (ImportAs is i) = hsep (map pretty is) <+> pretty "as" <+> pretty i
+	pretty (ImportWith is iel) = hsep (map pretty is) <+> pretty "with" <+> pretty iel
+
+
+instance Pretty ImportElement where
+    pretty (ElementAs s a) = pretty s <+> pretty "as" <+> pretty a
+    pretty (ElementSymbol s) = pretty s
 
 instance Pretty ExternDecl where
   pretty (ExternDecl i t) = pretty "extern" <+> pretty i <+> colon <+> pretty t
@@ -293,7 +318,7 @@ instance Pretty Expr where
     (hsep $ punctuate bar $ map prettyPatExprTup as)
    where
     prettyPatExprTup (p, e) = pretty p <+> pretty "=" <+> braces (pretty e)
-  pretty (ListExpr es) = brackets $ hsep $ punctuate comma $ map pretty es
+  -- pretty (ListExpr es) = brackets $ hsep $ punctuate comma $ map pretty es
   pretty NoExpr        = error "Unexpected NoExpr"
 
 instance Pretty Literal where

src/Front/Parser.y

@@ -41,6 +41,9 @@ import Data.Bifunctor (first)
   'fun'     { Token (_, TFun) }
   'match'   { Token (_, TMatch) }
   'extern'  { Token (_, TExtern) }
+  'import'  { Token (_, TImport) }
+  'with'    { Token (_, TWith) }
+  'as'      { Token (_, TAs)  }
   '='       { Token (_, TEq) }
   '<-'      { Token (_, TLarrow) }
   '->'      { Token (_, TRarrow) }
@@ -50,6 +53,7 @@ import Data.Bifunctor (first)
   ':'       { Token (_, TColon) }
   ';'       { Token (_, TSemicolon) }
   ','       { Token (_, TComma) }
+  '.'       { Token (_, TDot) }
   '_'       { Token (_, TUnderscore) }
   '@'       { Token (_, TAt) }
   '&'       { Token (_, TAmpersand) }
@@ -92,6 +96,25 @@ topDef                                --> TopDef
   | defType                             { TopType $1 }
   | defCBlock                           { TopCDefs $1 }
   | defExtern                           { TopExtern $1 }
+  | defImport                           { TopImport $1 }
+
+-- | Import Definition
+defImport
+: 'import' '{' importPath '}'               { ImportSym $3 }
+  | 'import' '{' importPath 'as' id '}'      { ImportAs $3 $5 }
+  | 'import' '{' importPath 'with' '{' elementItems '}' '}' { ImportWith $3 $6}
+
+importPath
+:   id                             { [$1] }
+  | id '.' importPath                      { $1 : $3 }
+
+elementItem
+:   id                             { ElementSymbol $1 }
+  | id 'as' id                     { ElementAs $1 $3 }
+
+elementItems
+: elementItem              { [$1] }
+  | elementItem ',' elementItems                   { $1 : $3 }
 
 -- | Algebraic data type definition.
 defType                               --> TypeDef
@@ -316,6 +339,12 @@ exprAtom
   | '(' ')'                             { Lit LitEvent }
   | '[' exprList ']'                    { ListExpr $2 }
   | '(' expr ',' exprTups ')'           { Tuple ($2 : $4)  }
+  | id '.' fullids                      { ImportId ($1 : $3) }
+
+-- fullIds
+fullids
+  : id                                    { [$1] }
+  | id '.' fullids                        { $1 : $3 }
 
 -- | List Expression.
 exprList

src/Front/RewriteImportId.hs

@@ -0,0 +1,68 @@
+module Front.RewriteImportId where
+import qualified Common.Compiler as Compiler
+import Common.Identifiers
+import Data.Bifunctor (first)
+import Data.Generics (Data (..), everywhere, mkT)
+import qualified Front.Ast as A
+import Data.List
+
+
+
+-- | Itereate the AST and first Import ASTs and generates a list of imported information
+extractImportList :: A.Program -> [A.Import]
+extractImportList (A.Program defs) =
+	foldr extractImportListTopDef [] defs
+	where extractImportListTopDef (A.TopImport imp) l = imp : l
+	      extractImportListTopDef _ l = l
+
+
+
+findRealIdentifierInImportAs :: [A.Import] -> A.Expr -> Maybe [Identifier]
+findRealIdentifierInImportAs [] id = Nothing
+findRealIdentifierInImportAs ((A.ImportAs ls id):rest) (impor@(A.ImportId iid@([id1, id2])))
+    | id1 == id = Just (id2:ls)
+	| otherwise = findRealIdentifierInImportAs rest impor
+
+findRealIdentifierInImportAs ((A.ImportWith ls iel):rest) (impor@(A.ImportId iid@(_:_))) =
+	if firstn == ls
+	then let res = findinImportElement laste iel in
+			       case res of
+					Just e -> Just (ls ++ [e])
+					_ -> Nothing
+	else findRealIdentifierInImportAs rest impor
+	where firstn = take ((length iid) - 1) iid
+	      laste = last iid
+
+
+findinImportElement element [] = Nothing
+findinImportElement element ((A.ElementSymbol id): res)
+	| id == element = Just id
+	| otherwise = findinImportElement element res
+
+
+desugarDef :: (Data a) => a -> a
+desugarDef = (everywhere $ mkT $ substIdentifier)
+
+
+-- | subst A.ImportId to a correct one
+substIdentifier :: A.Expr -> A.Expr
+substIdentifier (A.ImportId ids) = error ("unimplemented")
+substIdentifier e = e
+
+-- first get top import list, 
+
+-- importInTopLevel :: [Identifier] -> A.Program -> ()
+-- importInTopLevel impIds program =
+--   -- Check if imported expression is exactly one element longer and matches on of the top imports
+--   if any (\topLevelIds -> length impIds == length topLevelIds + 1 && zip impIds topLevelIds == topLevelIds) topLevelImportIds
+--     then ()
+--     else error "Import not found in top-level imports"
+--   where
+--     topLevelImports = extractImportList program
+--     topLevelImportIds = map importToList topLevelImports
+
+-- importToList :: A.Import -> [Identifier]
+-- importToList (A.ImportSym ids) = ids
+-- importToList (A.ImportAs ids _) = ids
+-- importToList (A.ImportWith ids _) = ids
+

src/Front/Scanner.x

@@ -43,7 +43,7 @@ $blank   = [\ \t]
 @newline = [\n] | [\r][\n] | [\r]
 @identifier = [a-zA-Z_] [a-zA-Z0-9_']*
 
-$symbolBase         = [\!\#\%\&\+\-\.\<\=\>\?\@\\\^\|\~]
+$symbolBase         = [\!\#\%\&\+\-\<\=\>\?\@\\\^\|\~]
 $symbolLeading      = [$symbolBase\*]
 $symbolAfterSlash   = [$symbolBase\_\:\"\']
 $symbolAny          = [$symbolBase\_\:\"\'\*]
@@ -132,13 +132,15 @@ tokens :-
     let                 { layout    TLet    TDBar }
     match               { layoutNL  TMatch  TBar }
     loop                { layout    TLoop   TSemicolon }
+    import              { layout  TImport TSemicolon }
     \=                  { layout    TEq     TSemicolon }
     \<\-                { layout    TLarrow TSemicolon }
     \=\>                { layout    TDRarrow TSemicolon}
     par                 { layout    TPar    TDBar }
     wait                { layout    TWait   TDBar }
     fun                 { layoutNL  TFun    TSemicolon }
     type                { layoutNL  TType   TBar }
+    with                { layout TWith TSemicolon }
 
     -- Keywords that just do as they be.
     extern              { keyword TExtern }
@@ -150,9 +152,12 @@ tokens :-
     \;                  { keyword TSemicolon }
     \:                  { keyword TColon }
     \,                  { keyword TComma }
+    \.                  { keyword TDot }
     \_                  { keyword TUnderscore }
     \@                  { keyword TAt }
     \&                  { keyword TAmpersand }
+    as                  { keyword TAs }
+
 
     -- Reserved keywords.
     do                  { reserved TDo }

src/Front/Scope.hs

@@ -353,6 +353,7 @@ scopeExpr (A.Seq e e') = mapM_ scopeExpr [e, e']
 scopeExpr (A.Lit _) = return ()
 scopeExpr (A.ListExpr l) = mapM_ scopeExpr l
 scopeExpr A.Break = return ()
+scopeExpr (A.ImportId _) = return ()
 scopeExpr (A.Tuple es) = mapM_ scopeExpr es
 scopeExpr (A.OpRegion e o) =
   throwError $

src/Front/Token.hs

@@ -52,6 +52,7 @@ data TokenType
   | TSemicolon
   | TBar
   | TComma
+  | TDot
   | TUnderscore
   | TAt
   | TAmpersand
@@ -61,6 +62,9 @@ data TokenType
   | TRbrace
   | TLbracket
   | TRbracket
+  | TAs
+  | TWith
+  | TImport
   | TInteger Integer
   | TString String
   | TId Identifier
@@ -127,6 +131,10 @@ instance Pretty TokenType where
   pretty TRbrace = pretty "}"
   pretty TLbracket = pretty "["
   pretty TRbracket = pretty "]"
+  pretty TImport = pretty "import"
+  pretty TAs = pretty "as"
+  pretty TWith = pretty "with"
+  pretty TDot = pretty "."
   pretty (TInteger i) = pretty $ show i
   pretty (TString s) = pretty $ "\"" <> s <> "\""
   pretty (TId i) = pretty i

src/IR/LowerAst.hs

@@ -168,6 +168,8 @@ lowerExpr (A.Tuple es) =
  where
   apply_recurse e []       = e
   apply_recurse e (x : xs) = apply_recurse (I.App e x untyped) xs
+lowerExpr (A.ImportId _) =
+  Compiler.unexpected "lowerExpr: Import Id Lowering"
 lowerExpr (A.ListExpr _) =
   Compiler.unexpected "lowerExpr: ListExprs should have already been desugared"
 

test/text/Tests/ScanBlocksSpec.hs

@@ -12,7 +12,7 @@ spec = do
   it "supports line continuations" $ do
     let input = [here|
           some long line
-              is continued with more indentation
+              is continued withe more indentation
           but this is not
         |]
         output =
@@ -21,7 +21,7 @@ spec = do
           , TId "line"
           , TId "is"
           , TId "continued"
-          , TId "with"
+          , TId "withe"
           , TId "more"
           , TId "indentation"
           , TDBar

test/text/Tests/ScanOperatorsSpec.hs

@@ -17,7 +17,6 @@ spec = do
     t "%"
     t "*"
     t "+"
-    t "."
     t "/"
     t "<"
     t "='"