firefly-compiler 0.4.87 → 0.4.89

package/compiler/Parser.ff

@@ -1184,11 +1184,44 @@ extend self: Parser {
     }
     
     parseDynamicMember(record: Term): Term {
-        self.skip(LArrowThin)
-        let token = if(self.current().is(LUpper)) {
-            self.skip(LUpper)
-        } elseIf {self.current().is(LLower)} {
+        let token = self.skip(LArrowThin)
+        if(self.current().rawIs("(")) {
+            let arguments = self.parseFunctionArguments(token.at(), trailing = False)
+            let effect = self.freshUnificationVariable(record.at)
+            arguments.first.indexWhere {!_.name.isEmpty()}.{
+                | None =>
+                    let objectTarget = DynamicCall(EField(token.at(), False, record, "object"), False)
+                    mutable result = ECall(record.at, objectTarget, effect, [], [], [])
+                    arguments.first.each {argument =>
+                        if(argument.name.isEmpty()) {
+                            throw(CompileError(argument.at, "Expected a named argument"))
+                        }
+                        let target = DynamicCall(EField(token.at(), False, record, "with"), False)
+                        result = ECall(record.at, target, effect, [], [
+                            Argument(argument.at, None, EString(argument.at, argument.name.grab()))
+                            argument
+                        ], [])
+                    }
+                    result
+                | Some(0) => 
+                    let target = DynamicCall(EField(token.at(), False, record, "new" + arguments.first.size()), False)
+                    ECall(record.at, target, effect, [], arguments.first, [])
+                | Some(i) => 
+                    throw(CompileError(arguments.first.grab(i).at, "Unexpected named argument"))
+            }
+        } elseIf {self.current().rawIs("{")} {
+            let lambda = self.parseLambda()
+            let effect = self.freshUnificationVariable(record.at)
+            let arguments = lambda.cases.grabFirst().patterns.size()
+            let target = DynamicCall(EField(token.at(), False, record, "function" + arguments), False)
+            ECall(record.at, target, effect, [], [
+                Argument(lambda.at, None, ELambda(lambda.at, lambda))
+            ], [])
+        } else:
+        let token = if(self.current().is(LLower)) {
             self.skip(LLower)
+        } elseIf {self.current().is(LUpper)} {
+            self.skip(LUpper)
         } else {
             self.skip(LString)
         }

package/compiler/Tokenizer.ff

@@ -162,7 +162,9 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                 let kind = if(code.grab(i) >= 'a') {LLower} else {LUpper}
                 i += 1
                 while {i < code.size() && code.grab(i).isAsciiLetterOrDigit()} {i += 1}
-                if(i < code.size() && kind == LUpper && code.grab(i) == '.') {
+                if(i < code.size() && kind == LUpper && code.grab(i) == '.' && (
+                    tokens.isEmpty() || tokens.grabLast().kind != LArrowThin
+                )) {
                     i += 1
                     emitToken(LNamespace, start, i)
                 } else {

package/compression/.firefly/package.ff

@@ -0,0 +1 @@
+dependency ff:unsafejs:0.0.0

package/compression/Compression.ff

@@ -0,0 +1,55 @@
+import UnsafeJs from ff:unsafejs
+
+capability Compression {}
+
+extend self: Compression {
+
+    compressBrotli(uncompressed: Buffer, level: Int = 4): Buffer {
+        internalCompress("brotli", level, uncompressed)
+    }
+
+    decompressBrotli(compressed: Buffer): Buffer {
+        
+    }
+
+    compressGzip(uncompressed: Buffer, level: Int = 6): Buffer {
+        internalCompress("gzip", level, uncompressed)
+    }
+
+    decompressGzip(compressed: Buffer): Buffer {
+        
+    }
+
+    compressDeflate(uncompressed: Buffer, level: Int = 6): Buffer {
+        internalCompress("deflate", level, uncompressed)
+    }
+
+    decompressDeflate(compressed: Buffer): Buffer {
+        
+    }
+
+}
+
+newForBrowserSystem(browserSystem: BrowserSystem): Compression
+    target js async "return globalThis"
+
+newForNodeSystem(nodeSystem: NodeSystem): Compression
+    target js async "return globalThis"
+
+internalCompress(algorithm: String, level: Int, buffer: Buffer): Buffer {
+    let js = UnsafeJs.jsSystem()
+    let dataView = UnsafeJs.toJsValue(buffer)
+    let uint8Array = js->Uint8Array->(dataView->buffer, dataView->byteOffset, dataView->byteLength)
+    let stream = js->ReadableStream->(js->(
+        start = js->{controller =>
+            controller->enqueue(uint8Array)
+            controller->close()
+        }
+    ))
+    let ds = js->DecompressionStream->(algorithm)
+    let decompressedStream = stream->pipeThrough(ds)
+    let response = UnsafeJs.await {js->Response->(decompressedStream)}
+    let decompressedData = UnsafeJs.await {response->arrayBuffer()}
+    js->DataView->(decompressedData).grabBuffer()
+}
+

package/output/js/ff/compiler/Parser.mjs

@@ -1539,11 +1539,46 @@ return result_
 }
 
 export function Parser_parseDynamicMember(self_, record_) {
-ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
-const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
-? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LUpper())
-: ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
+const token_ = ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
+const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, ff_compiler_Token.Token_at(token_), false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+{
+const _1 = ff_core_List.List_indexWhere(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+}));
+if(_1.None) {
+const objectTarget_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "object"), false);
+let result_ = ff_compiler_Syntax.ECall(record_.at_, objectTarget_, effect_, [], [], []);
+ff_core_List.List_each(arguments_.first_, ((argument_) => {
+if(ff_core_Option.Option_isEmpty(argument_.name_)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Expected a named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "with"), false);
+result_ = ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(argument_.at_, ff_core_Option.None(), ff_compiler_Syntax.EString(argument_.at_, ff_core_Option.Option_grab(argument_.name_))), argument_], [])
+}));
+return result_
+}
+if(_1.Some && _1.value_ === 0) {
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("new" + ff_core_List.List_size(arguments_.first_))), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], arguments_.first_, [])
+}
+if(_1.Some) {
+const i_ = _1.value_;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(arguments_.first_, i_).at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
+}
+} else if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
+const lambda_ = ff_compiler_Parser.Parser_parseLambda(self_, 0, false, false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+const arguments_ = ff_core_List.List_size(ff_core_List.List_grabFirst(lambda_.cases_).patterns_);
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("function" + arguments_)), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(lambda_.at_, ff_core_Option.None(), ff_compiler_Syntax.ELambda(lambda_.at_, lambda_))], [])
+} else {
+const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
 ? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
+: ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
+? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LUpper())
 : ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LString()));
 const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (ff_compiler_Token.Token_is(token_, ff_compiler_Token.LString())
 ? ff_compiler_Token.Token_raw(token_)
@@ -1578,6 +1613,7 @@ const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_comp
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_)], [])
 }
 }
+}
 
 export function Parser_parseAtom(self_) {
 if(ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LString())) {
@@ -3108,11 +3144,46 @@ return result_
 }
 
 export async function Parser_parseDynamicMember$(self_, record_, $task) {
-ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
-const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
-? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LUpper())
-: ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
+const token_ = ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
+const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, ff_compiler_Token.Token_at(token_), false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+{
+const _1 = ff_core_List.List_indexWhere(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+}));
+if(_1.None) {
+const objectTarget_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "object"), false);
+let result_ = ff_compiler_Syntax.ECall(record_.at_, objectTarget_, effect_, [], [], []);
+ff_core_List.List_each(arguments_.first_, ((argument_) => {
+if(ff_core_Option.Option_isEmpty(argument_.name_)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Expected a named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "with"), false);
+result_ = ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(argument_.at_, ff_core_Option.None(), ff_compiler_Syntax.EString(argument_.at_, ff_core_Option.Option_grab(argument_.name_))), argument_], [])
+}));
+return result_
+}
+if(_1.Some && _1.value_ === 0) {
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("new" + ff_core_List.List_size(arguments_.first_))), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], arguments_.first_, [])
+}
+if(_1.Some) {
+const i_ = _1.value_;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(arguments_.first_, i_).at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
+}
+} else if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
+const lambda_ = ff_compiler_Parser.Parser_parseLambda(self_, 0, false, false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+const arguments_ = ff_core_List.List_size(ff_core_List.List_grabFirst(lambda_.cases_).patterns_);
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("function" + arguments_)), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(lambda_.at_, ff_core_Option.None(), ff_compiler_Syntax.ELambda(lambda_.at_, lambda_))], [])
+} else {
+const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
 ? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
+: ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
+? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LUpper())
 : ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LString()));
 const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (ff_compiler_Token.Token_is(token_, ff_compiler_Token.LString())
 ? ff_compiler_Token.Token_raw(token_)
@@ -3147,6 +3218,7 @@ const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_comp
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_)], [])
 }
 }
+}
 
 export async function Parser_parseAtom$(self_, $task) {
 if(ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LString())) {

package/output/js/ff/compiler/Tokenizer.mjs

@@ -245,7 +245,7 @@ i_ += 1;
 while(((i_ < ff_core_String.String_size(code_)) && ff_core_Char.Char_isAsciiLetterOrDigit(ff_core_String.String_grab(code_, i_)))) {
 i_ += 1
 };
-if((((i_ < ff_core_String.String_size(code_)) && ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind.equals_(kind_, ff_compiler_Token.LUpper())) && (ff_core_String.String_grab(code_, i_) === 46))) {
+if(((((i_ < ff_core_String.String_size(code_)) && ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind.equals_(kind_, ff_compiler_Token.LUpper())) && (ff_core_String.String_grab(code_, i_) === 46)) && (ff_core_Array.Array_isEmpty(tokens_) || ff_core_Equal.notEquals_(ff_core_Array.Array_grabLast(tokens_).kind_, ff_compiler_Token.LArrowThin(), ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind)))) {
 i_ += 1;
 emitToken_(ff_compiler_Token.LNamespace(), start_, i_)
 } else {
@@ -489,7 +489,7 @@ i_ += 1;
 while(((i_ < ff_core_String.String_size(code_)) && ff_core_Char.Char_isAsciiLetterOrDigit(ff_core_String.String_grab(code_, i_)))) {
 i_ += 1
 };
-if((((i_ < ff_core_String.String_size(code_)) && ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind.equals_(kind_, ff_compiler_Token.LUpper())) && (ff_core_String.String_grab(code_, i_) === 46))) {
+if(((((i_ < ff_core_String.String_size(code_)) && ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind.equals_(kind_, ff_compiler_Token.LUpper())) && (ff_core_String.String_grab(code_, i_) === 46)) && (ff_core_Array.Array_isEmpty(tokens_) || ff_core_Equal.notEquals_(ff_core_Array.Array_grabLast(tokens_).kind_, ff_compiler_Token.LArrowThin(), ff_compiler_Token.ff_core_Equal_Equal$ff_compiler_Token_TokenKind)))) {
 i_ += 1;
 emitToken_(ff_compiler_Token.LNamespace(), start_, i_)
 } else {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.87",
+    "version": "0.4.89",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/unsafejs/UnsafeJs.ff

@@ -17,3 +17,7 @@ throwIfCancelled(): Unit
 cancelled(): Bool
     // Replaced by the compiler
     target js sync "return false"
+
+toJsValue[T](value: T): JsValue
+    target js sync "return value_"
+    

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.87",
+    "version": "0.4.89",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"