firefly-compiler 0.4.21 → 0.4.23

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

@@ -541,11 +541,36 @@ ff_compiler_Unification.Unification_unify(self_.unification_, at_, expected_, in
 const parameters_ = ff_core_List.List_sortBy(instantiated_.scheme_.signature_.parameters_, ((_w1) => {
 return _w1.name_
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+const paramtersWithFieldAt_ = ff_core_List.List_map(parameters_, ((p_) => {
+{
+const _1 = p_.valueType_;
+if(_1.TConstructor) {
+const t_ = _1;
+{
+const _1 = t_;
+{
+const _c = _1;
+return ff_compiler_Syntax.TConstructor(p_.at_, _c.name_, _c.generics_)
+}
+}
+return
+}
+if(_1.TVariable) {
+const t_ = _1;
+{
+const _1 = t_;
+{
+const _c = _1;
+return ff_compiler_Syntax.TVariable(p_.at_, _c.index_)
+}
+}
+return
+}
+}
+}));
 const recordType_ = ff_compiler_Syntax.TConstructor(at_, ("Record$" + ff_core_List.List_join(ff_core_List.List_map(parameters_, ((_w1) => {
 return _w1.name_
-})), "$")), ff_core_List.List_map(parameters_, ((_w1) => {
-return _w1.valueType_
-})));
+})), "$")), paramtersWithFieldAt_);
 return ff_core_List.List_toMap(ff_core_List.List_map(ff_core_Option.Option_toList(variableOption_), ((_w1) => {
 return ff_core_Pair.Pair(_w1, ff_core_Pair.Pair(variableAt_, recordType_))
 })), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
@@ -650,12 +675,22 @@ const t_ = _1;
 const name_ = _1.name_;
 const typeArguments_ = _1.generics_;
 if(ff_core_String.String_startsWith(name_, "Record$", 0)) {
-if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, e_.at_)) {
-const symbolHook_ = ff_compiler_LspHook.SymbolHook(e_.field_, e_.at_, e_.at_);
-const noEffect_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
-ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.InferRecordFieldHook(self_.unification_, environment_, expected_, t_, e_.field_))
-};
 const fieldNames_ = ff_core_List.List_dropFirst(ff_core_String.String_split(name_, 36), 1);
+if(ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) {
+ff_core_List.List_each(ff_core_List.List_zip(fieldNames_, typeArguments_), ((_1) => {
+{
+const fieldName_ = _1.first_;
+const fieldType_ = _1.second_;
+if((e_.field_ === fieldName_)) {
+const definedAt_ = ff_compiler_Unification.Unification_substitute(self_.unification_, fieldType_).at_;
+if((ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, e_.at_) || ff_compiler_LspHook.LspHook_isDefinedAt(self_.lspHook_, definedAt_))) {
+ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.InferRecordFieldHook(e_.at_, self_.unification_, environment_, expected_, t_, e_.field_))
+}
+}
+return
+}
+}))
+};
 return ff_core_Option.Option_else(ff_core_Option.Option_elseIf(ff_core_Option.Option_map(ff_core_Option.Option_map(ff_core_List.List_find(ff_core_List.List_pairs(fieldNames_), ((_w1) => {
 return (_w1.second_ === e_.field_)
 })), ((_w1) => {
@@ -994,7 +1029,11 @@ return term_
 const call_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return {
+function_: call_.function_,
+tailCall_: call_.tailCall_
+}
+return
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in the Inference phase")
@@ -1230,19 +1269,14 @@ return newValue_
 }
 
 export function Inference_inferMethodCall(self_, environment_, expected_, signature_, instantiation_, term_, record_, recordType_, name_) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
-const call_ = (((_1) => {
+const tailCall_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return call_.tailCall_
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in inferMethodCall")
@@ -1258,28 +1292,29 @@ ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, signat
 const _1 = e_;
 {
 const _c = _1;
-return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, call_.tailCall_, false), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
+return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, tailCall_, false), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
 return _w1.second_
 })), [selfArgument_, ...arguments_], _c.dictionaries_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export function Inference_inferFunctionCall(self_, environment_, expected_, signature_, instanceCall_, instantiation_, term_, name_) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
-const call_ = (((_1) => {
+const tailCall_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return call_.tailCall_
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in inferFunctionCall")
@@ -1292,29 +1327,34 @@ ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, signat
 const _1 = e_;
 {
 const _c = _1;
-return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, call_.tailCall_, instanceCall_), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
+return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, tailCall_, instanceCall_), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
 return _w1.second_
 })), arguments_, _c.dictionaries_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export function Inference_inferLambdaCall(self_, environment_, expected_, term_) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
 const call_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
 if((!call_.tailCall_)) {
-return call_
+return {
+function_: call_.function_,
+tailCall_: call_.tailCall_
+}
+return
 }
 }
 if(_1.DynamicCall) {
@@ -1361,18 +1401,19 @@ return ff_compiler_Syntax.DynamicCall(function_, _c.tailCall_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export function Inference_inferOperator(self_, environment_, expected_, operator_, term_) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
 const target_ = ff_compiler_Syntax.StaticCall(operator_, false, false);
 {
 const _1 = e_.arguments_;
@@ -1586,6 +1627,12 @@ return term_
 return ff_compiler_Inference.fail_(e_.at_, ("Unknown operator: " + operator_))
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export function Inference_inferEtaExpansion(self_, environment_, expected_, at_, signature_, term_) {
@@ -2169,11 +2216,36 @@ ff_compiler_Unification.Unification_unify(self_.unification_, at_, expected_, in
 const parameters_ = ff_core_List.List_sortBy(instantiated_.scheme_.signature_.parameters_, ((_w1) => {
 return _w1.name_
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+const paramtersWithFieldAt_ = ff_core_List.List_map(parameters_, ((p_) => {
+{
+const _1 = p_.valueType_;
+if(_1.TConstructor) {
+const t_ = _1;
+{
+const _1 = t_;
+{
+const _c = _1;
+return ff_compiler_Syntax.TConstructor(p_.at_, _c.name_, _c.generics_)
+}
+}
+return
+}
+if(_1.TVariable) {
+const t_ = _1;
+{
+const _1 = t_;
+{
+const _c = _1;
+return ff_compiler_Syntax.TVariable(p_.at_, _c.index_)
+}
+}
+return
+}
+}
+}));
 const recordType_ = ff_compiler_Syntax.TConstructor(at_, ("Record$" + ff_core_List.List_join(ff_core_List.List_map(parameters_, ((_w1) => {
 return _w1.name_
-})), "$")), ff_core_List.List_map(parameters_, ((_w1) => {
-return _w1.valueType_
-})));
+})), "$")), paramtersWithFieldAt_);
 return ff_core_List.List_toMap(ff_core_List.List_map(ff_core_Option.Option_toList(variableOption_), ((_w1) => {
 return ff_core_Pair.Pair(_w1, ff_core_Pair.Pair(variableAt_, recordType_))
 })), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
@@ -2278,12 +2350,22 @@ const t_ = _1;
 const name_ = _1.name_;
 const typeArguments_ = _1.generics_;
 if(ff_core_String.String_startsWith(name_, "Record$", 0)) {
-if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, e_.at_)) {
-const symbolHook_ = ff_compiler_LspHook.SymbolHook(e_.field_, e_.at_, e_.at_);
-const noEffect_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
-ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.InferRecordFieldHook(self_.unification_, environment_, expected_, t_, e_.field_))
-};
 const fieldNames_ = ff_core_List.List_dropFirst(ff_core_String.String_split(name_, 36), 1);
+if(ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)) {
+ff_core_List.List_each(ff_core_List.List_zip(fieldNames_, typeArguments_), ((_1) => {
+{
+const fieldName_ = _1.first_;
+const fieldType_ = _1.second_;
+if((e_.field_ === fieldName_)) {
+const definedAt_ = ff_compiler_Unification.Unification_substitute(self_.unification_, fieldType_).at_;
+if((ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, e_.at_) || ff_compiler_LspHook.LspHook_isDefinedAt(self_.lspHook_, definedAt_))) {
+ff_compiler_LspHook.LspHook_emit(self_.lspHook_, ff_compiler_LspHook.InferRecordFieldHook(e_.at_, self_.unification_, environment_, expected_, t_, e_.field_))
+}
+}
+return
+}
+}))
+};
 return ff_core_Option.Option_else(ff_core_Option.Option_elseIf(ff_core_Option.Option_map(ff_core_Option.Option_map(ff_core_List.List_find(ff_core_List.List_pairs(fieldNames_), ((_w1) => {
 return (_w1.second_ === e_.field_)
 })), ((_w1) => {
@@ -2622,7 +2704,11 @@ return term_
 const call_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return {
+function_: call_.function_,
+tailCall_: call_.tailCall_
+}
+return
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in the Inference phase")
@@ -2858,19 +2944,14 @@ return newValue_
 }
 
 export async function Inference_inferMethodCall$(self_, environment_, expected_, signature_, instantiation_, term_, record_, recordType_, name_, $task) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
-const call_ = (((_1) => {
+const tailCall_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return call_.tailCall_
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in inferMethodCall")
@@ -2886,28 +2967,29 @@ ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, signat
 const _1 = e_;
 {
 const _c = _1;
-return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, call_.tailCall_, false), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
+return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, tailCall_, false), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
 return _w1.second_
 })), [selfArgument_, ...arguments_], _c.dictionaries_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export async function Inference_inferFunctionCall$(self_, environment_, expected_, signature_, instanceCall_, instantiation_, term_, name_, $task) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
-const call_ = (((_1) => {
+const tailCall_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
-return call_
+return call_.tailCall_
 }
 if(_1.StaticCall) {
 return ff_compiler_Inference.fail_(e_.at_, "Internal error: Static calls not expected in inferFunctionCall")
@@ -2920,29 +3002,34 @@ ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, signat
 const _1 = e_;
 {
 const _c = _1;
-return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, call_.tailCall_, instanceCall_), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
+return ff_compiler_Syntax.ECall(_c.at_, ff_compiler_Syntax.StaticCall(name_, tailCall_, instanceCall_), signature_.effect_, ff_core_List.List_map(instantiation_, ((_w1) => {
 return _w1.second_
 })), arguments_, _c.dictionaries_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export async function Inference_inferLambdaCall$(self_, environment_, expected_, term_, $task) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
 const call_ = (((_1) => {
 if(_1.DynamicCall) {
 const call_ = _1;
 if((!call_.tailCall_)) {
-return call_
+return {
+function_: call_.function_,
+tailCall_: call_.tailCall_
+}
+return
 }
 }
 if(_1.DynamicCall) {
@@ -2989,18 +3076,19 @@ return ff_compiler_Syntax.DynamicCall(function_, _c.tailCall_)
 return
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export async function Inference_inferOperator$(self_, environment_, expected_, operator_, term_, $task) {
-const e_ = (((_1) => {
+{
+const _1 = term_;
 if(_1.ECall) {
 const e_ = _1;
-return e_
-}
-{
-return ff_compiler_Inference.fail_(term_.at_, "Call expected")
-}
-}))(term_);
 const target_ = ff_compiler_Syntax.StaticCall(operator_, false, false);
 {
 const _1 = e_.arguments_;
@@ -3214,6 +3302,12 @@ return term_
 return ff_compiler_Inference.fail_(e_.at_, ("Unknown operator: " + operator_))
 }
 }
+return
+}
+{
+return ff_compiler_Inference.fail_(term_.at_, "Call expected")
+}
+}
 }
 
 export async function Inference_inferEtaExpansion$(self_, environment_, expected_, at_, signature_, term_, $task) {

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

@@ -204,16 +204,17 @@ return t_.name_
 }
 
 export function firstTypeName_(types_) {
-return (((_1) => {
+{
+const _1 = ff_core_List.List_grabFirst(types_);
 if(_1.TConstructor) {
 const t_ = _1;
-return t_
+return t_.name_
 }
 if(_1.TVariable) {
 const t_ = _1;
 return ff_compiler_JsEmitter.fail_(t_.at_, " is still a unification variable")
 }
-}))(ff_core_List.List_grabFirst(types_)).name_
+}
 }
 
 export function makeDictionaryName_(traitName_, typeName_) {
@@ -347,16 +348,17 @@ return t_.name_
 }
 
 export async function firstTypeName_$(types_, $task) {
-return (((_1) => {
+{
+const _1 = ff_core_List.List_grabFirst(types_);
 if(_1.TConstructor) {
 const t_ = _1;
-return t_
+return t_.name_
 }
 if(_1.TVariable) {
 const t_ = _1;
 return ff_compiler_JsEmitter.fail_(t_.at_, " is still a unification variable")
 }
-}))(ff_core_List.List_grabFirst(types_)).name_
+}
 }
 
 export async function makeDictionaryName_$(traitName_, typeName_, $task) {

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

@@ -199,8 +199,8 @@ return {InferArgumentHook: true, unification_, environment_, isCopy_, callAt_, c
 export function InferLookupHook(unification_, environment_, expected_, selfVariable_, symbol_, instantiated_) {
 return {InferLookupHook: true, unification_, environment_, expected_, selfVariable_, symbol_, instantiated_};
 }
-export function InferRecordFieldHook(unification_, environment_, expected_, recordType_, fieldName_) {
-return {InferRecordFieldHook: true, unification_, environment_, expected_, recordType_, fieldName_};
+export function InferRecordFieldHook(usageAt_, unification_, environment_, expected_, recordType_, fieldName_) {
+return {InferRecordFieldHook: true, usageAt_, unification_, environment_, expected_, recordType_, fieldName_};
 }
 
 
@@ -271,6 +271,7 @@ const pattern_ = hook_a.pattern_;
 return "InferPatternHook(...)"
 }
 if(hook_a.InferRecordFieldHook) {
+const usageAt_ = hook_a.usageAt_;
 const unification_ = hook_a.unification_;
 const environment_ = hook_a.environment_;
 const expected_ = hook_a.expected_;
@@ -406,6 +407,7 @@ const pattern_ = hook_a.pattern_;
 return "InferPatternHook(...)"
 }
 if(hook_a.InferRecordFieldHook) {
+const usageAt_ = hook_a.usageAt_;
 const unification_ = hook_a.unification_;
 const environment_ = hook_a.environment_;
 const expected_ = hook_a.expected_;

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

@@ -184,7 +184,10 @@ const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSyst
 ff_compiler_Main.prepareFireflyDirectory_(ff_core_NodeSystem.NodeSystem_path(system_, "."));
 const localMainFile_ = ff_core_Path.Path_base(ff_core_NodeSystem.NodeSystem_path(system_, mainFile_));
 buildScript_(localMainFile_, resolvedDependencies_.mainPackagePair_, ff_compiler_JsEmitter.EmitNode(), resolvedDependencies_);
-ff_compiler_Main.importAndRun_(fireflyPath_, "node", resolvedDependencies_.mainPackagePair_, localMainFile_, arguments_)
+if((!ff_compiler_Main.importAndRun_(fireflyPath_, "node", resolvedDependencies_.mainPackagePair_, localMainFile_, arguments_))) {
+const at_ = ff_compiler_Syntax.Location(ff_core_Path.Path_absolute(ff_core_NodeSystem.NodeSystem_path(system_, (mainFile_ + ".ff"))), 1, 1);
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, "This module does not contain a 'nodeMain' function"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
 return
 }
 if(command_a.BrowserCommand) {
@@ -211,7 +214,7 @@ if(command_a.CheckCommand) {
 const filePath_ = command_a.filePath_;
 const errors_ = ff_compiler_Builder.check_(system_, fireflyPath_, ff_core_NodeSystem.NodeSystem_path(system_, filePath_), ff_core_Option.None(), ff_core_Map.empty_(), ff_compiler_LspHook.disabled_(), true);
 if((!ff_core_List.List_isEmpty(errors_))) {
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(errors_), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_distinct(errors_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_CompileError)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
 return
 }
@@ -428,7 +431,10 @@ const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await f
 (await ff_compiler_Main.prepareFireflyDirectory_$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".", $task)), $task));
 const localMainFile_ = (await ff_core_Path.Path_base$((await ff_core_NodeSystem.NodeSystem_path$(system_, mainFile_, $task)), $task));
 (await buildScript_$(localMainFile_, resolvedDependencies_.mainPackagePair_, ff_compiler_JsEmitter.EmitNode(), resolvedDependencies_, $task));
-(await ff_compiler_Main.importAndRun_$(fireflyPath_, "node", resolvedDependencies_.mainPackagePair_, localMainFile_, arguments_, $task))
+if((!(await ff_compiler_Main.importAndRun_$(fireflyPath_, "node", resolvedDependencies_.mainPackagePair_, localMainFile_, arguments_, $task)))) {
+const at_ = ff_compiler_Syntax.Location((await ff_core_Path.Path_absolute$((await ff_core_NodeSystem.NodeSystem_path$(system_, (mainFile_ + ".ff"), $task)), $task)), 1, 1);
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, "This module does not contain a 'nodeMain' function"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
 return
 }
 if(command_a.BrowserCommand) {
@@ -455,7 +461,7 @@ if(command_a.CheckCommand) {
 const filePath_ = command_a.filePath_;
 const errors_ = (await ff_compiler_Builder.check_$(system_, fireflyPath_, (await ff_core_NodeSystem.NodeSystem_path$(system_, filePath_, $task)), ff_core_Option.None(), ff_core_Map.empty_(), ff_compiler_LspHook.disabled_(), true, $task));
 if((!ff_core_List.List_isEmpty(errors_))) {
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(errors_), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_distinct(errors_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_CompileError)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
 return
 }
@@ -626,7 +632,12 @@ export async function importAndRun_$(fireflyPath_, target_, packagePair_, mainFi
         const workingDirectory = cwd.indexOf(':') == 1 ? 'file:///' + cwd : cwd;
         const packagePath = packagePair_.group_ + "/" + packagePair_.name_
         const main = await import(workingDirectory + "/.firefly/output/" + target_ + "/" + packagePath + "/" + mainFile_ + ".mjs");
-        await main.$run$(fireflyPath_, arguments_)
+        if(typeof main.$run$ !== 'undefined') {
+            await main.$run$(fireflyPath_, arguments_);
+            return true;
+        } else {
+            return false;
+        }
     
 }
 

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

@@ -215,8 +215,8 @@ return convertPattern_(pattern_)
 }))), ((_1) => {
 if(_1.second_.Some) {
 const i_ = _1.first_;
-const p_ = _1.second_.value_;
-return ff_core_Option.Some(ff_core_Pair.Pair(("" + i_), p_))
+const info_ = _1.second_.value_;
+return ff_core_Option.Some(ff_core_Pair.Pair(("" + i_), info_))
 }
 {
 return ff_core_Option.None()
@@ -385,8 +385,8 @@ return convertPattern_(pattern_)
 }))), ((_1) => {
 if(_1.second_.Some) {
 const i_ = _1.first_;
-const p_ = _1.second_.value_;
-return ff_core_Option.Some(ff_core_Pair.Pair(("" + i_), p_))
+const info_ = _1.second_.value_;
+return ff_core_Option.Some(ff_core_Pair.Pair(("" + i_), info_))
 }
 {
 return ff_core_Option.None()