From 3e00b42b87ffe9a790440e4b290aca67fd6a631e Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Sun, 15 May 2022 15:01:05 -0700 Subject: [PATCH 01/14] Applied 'migrate-syntax lib' Fixed type annotations on toString methods. --- compiler/build.sbt | 6 +- .../src/main/scala/analysis/Analysis.scala | 4 +- .../scala/analysis/Analyzers/Analyzer.scala | 2 +- .../Analyzers/ComponentAnalyzer.scala | 2 +- .../analysis/Analyzers/EnumAnalyzer.scala | 2 +- .../analysis/Analyzers/ModuleAnalyzer.scala | 2 +- .../analysis/Analyzers/TopologyAnalyzer.scala | 2 +- .../Analyzers/TypeExpressionAnalyzer.scala | 44 ++++---- .../analysis/Analyzers/UseAnalyzer.scala | 16 +-- .../CheckSemantics/CheckComponentDefs.scala | 16 +-- .../CheckComponentInstanceDefs.scala | 4 +- .../CheckSemantics/CheckExprTypes.scala | 46 ++++---- .../CheckSemantics/CheckPortDefs.scala | 2 +- .../CheckSemantics/CheckSpecLocs.scala | 12 +- .../CheckSemantics/CheckTopologyDefs.scala | 8 +- .../CheckSemantics/CheckTypeUses.scala | 20 ++-- .../CheckSemantics/CheckUseDefCycles.scala | 16 +-- .../analysis/CheckSemantics/CheckUses.scala | 18 +-- .../CheckSemantics/EnterSymbols.scala | 22 ++-- .../CheckSemantics/EvalConstantExprs.scala | 26 ++--- .../EvalImpliedEnumConsts.scala | 2 +- .../CheckSemantics/FinalizeTypeDefs.scala | 24 ++-- .../ComputeDependencies/BuildSpecLocMap.scala | 2 +- .../ComputeFrameworkDependencies.scala | 8 +- .../Framework/FrameworkDependency.scala | 2 +- .../ComputeDependencies/MapUsesToLocs.scala | 12 +- .../scala/analysis/Semantics/Command.scala | 6 +- .../scala/analysis/Semantics/Component.scala | 6 +- .../Semantics/ComponentInstance.scala | 2 +- .../scala/analysis/Semantics/Connection.scala | 12 +- .../Semantics/ConnectionPattern.scala | 2 +- .../main/scala/analysis/Semantics/Event.scala | 2 +- .../scala/analysis/Semantics/Format.scala | 5 +- .../analysis/Semantics/InitSpecifier.scala | 2 +- .../main/scala/analysis/Semantics/Name.scala | 12 +- .../scala/analysis/Semantics/NameGroup.scala | 2 +- .../analysis/Semantics/NameSymbolMap.scala | 6 +- .../analysis/Semantics/NestedScope.scala | 12 +- .../main/scala/analysis/Semantics/Param.scala | 2 +- .../analysis/Semantics/PortInstance.scala | 14 +-- .../Semantics/PortInstanceIdentifier.scala | 4 +- .../MatchedPortNumbering.scala | 2 +- .../ResolveTopology/PatternResolver.scala | 36 +++--- .../ResolveTopology/PortNumberingState.scala | 4 +- .../main/scala/analysis/Semantics/Scope.scala | 6 +- .../scala/analysis/Semantics/TlmChannel.scala | 2 +- .../scala/analysis/Semantics/Topology.scala | 8 +- .../main/scala/analysis/Semantics/Type.scala | 59 +++++----- .../analysis/Semantics/TypeVisitor.scala | 2 +- .../analysis/Semantics/UseDefMatching.scala | 2 +- .../main/scala/analysis/Semantics/Value.scala | 69 ++++++------ .../analysis/Semantics/ValueVisitor.scala | 2 +- .../src/main/scala/analysis/UsedSymbols.scala | 12 +- compiler/lib/src/main/scala/ast/Ast.scala | 10 +- compiler/lib/src/main/scala/ast/AstNode.scala | 4 +- .../src/main/scala/ast/AstStateVisitor.scala | 2 +- .../lib/src/main/scala/ast/Locations.scala | 6 +- .../src/main/scala/codegen/AstWriter.scala | 80 ++++++------- .../scala/codegen/ComputeGeneratedFiles.scala | 4 +- .../codegen/CppWriter/ComputeCppFiles.scala | 12 +- .../codegen/CppWriter/ConstantCppWriter.scala | 10 +- .../main/scala/codegen/CppWriter/CppDoc.scala | 2 +- .../codegen/CppWriter/CppDocCppWriter.scala | 14 +-- .../codegen/CppWriter/CppDocHppWriter.scala | 20 ++-- .../codegen/CppWriter/CppDocWriter.scala | 24 ++-- .../scala/codegen/CppWriter/CppWriter.scala | 24 ++-- .../codegen/CppWriter/CppWriterState.scala | 6 +- .../TopologyCppWriterUtils.scala | 20 ++-- .../src/main/scala/codegen/FppWriter.scala | 106 +++++++++--------- .../src/main/scala/codegen/Indentation.scala | 6 +- .../lib/src/main/scala/codegen/Line.scala | 18 +-- .../src/main/scala/codegen/LineUtils.scala | 14 +-- .../scala/codegen/LocateDefsFppWriter.scala | 22 ++-- .../XmlFppWriter/ArrayXmlFppWriter.scala | 3 +- .../XmlFppWriter/ComponentXmlFppWriter.scala | 39 +++---- .../FormalParamsXmlFppWriter.scala | 3 +- .../XmlFppWriter/PortXmlFppWriter.scala | 3 +- .../XmlFppWriter/StructXmlFppWriter.scala | 3 +- .../codegen/XmlFppWriter/XmlFppWriter.scala | 16 +-- .../codegen/XmlWriter/ArrayXmlWriter.scala | 2 +- .../XmlWriter/ComponentXmlWriter.scala | 2 +- .../codegen/XmlWriter/ComputeXmlFiles.scala | 16 +-- .../codegen/XmlWriter/EnumXmlWriter.scala | 2 +- .../XmlWriter/FormalParamsXmlWriter.scala | 4 +- .../codegen/XmlWriter/PortXmlWriter.scala | 2 +- .../codegen/XmlWriter/StructXmlWriter.scala | 4 +- .../codegen/XmlWriter/TopologyXmlWriter.scala | 2 +- .../codegen/XmlWriter/TypeXmlWriter.scala | 10 +- .../codegen/XmlWriter/ValueXmlWriter.scala | 4 +- .../scala/codegen/XmlWriter/XmlTags.scala | 12 +- .../scala/codegen/XmlWriter/XmlWriter.scala | 16 +-- .../codegen/XmlWriter/XmlWriterState.scala | 18 +-- .../lib/src/main/scala/syntax/Lexer.scala | 15 +-- .../lib/src/main/scala/syntax/Parser.scala | 4 +- .../scala/transform/ResolveSpecInclude.scala | 6 +- compiler/lib/src/main/scala/util/Error.scala | 18 +-- compiler/lib/src/main/scala/util/File.scala | 2 +- .../lib/src/main/scala/util/Location.scala | 2 +- .../src/test/scala/semantics/FormatSpec.scala | 2 +- .../src/test/scala/semantics/Helpers.scala | 6 +- .../lib/src/test/scala/semantics/Types.scala | 16 +-- .../lib/src/test/scala/semantics/Values.scala | 80 ++++++------- compiler/project/assembly.sbt | 2 +- compiler/project/build.properties | 2 +- compiler/project/scala3-migration.sbt | 2 + 105 files changed, 673 insertions(+), 662 deletions(-) create mode 100644 compiler/project/scala3-migration.sbt diff --git a/compiler/build.sbt b/compiler/build.sbt index 826b8a285..fb60cb8f5 100644 --- a/compiler/build.sbt +++ b/compiler/build.sbt @@ -15,9 +15,9 @@ lazy val settings = Seq( lazy val dependencies = Seq( "com.github.scopt" %% "scopt" % "4.0.1", - "org.scala-lang.modules" %% "scala-parser-combinators" % "2.0.0", - "org.scala-lang.modules" %% "scala-xml" % "2.0.1", - "org.scalatest" % "scalatest_2.13" % "3.1.0" % "test", + "org.scala-lang.modules" %% "scala-parser-combinators" % "2.1.1", + "org.scala-lang.modules" %% "scala-xml" % "2.1.0", + "org.scalatest" %% "scalatest" % "3.2.12" % "test", ) lazy val root = (project in file(".")) diff --git a/compiler/lib/src/main/scala/analysis/Analysis.scala b/compiler/lib/src/main/scala/analysis/Analysis.scala index c0fae93db..f3c2f8c74 100644 --- a/compiler/lib/src/main/scala/analysis/Analysis.scala +++ b/compiler/lib/src/main/scala/analysis/Analysis.scala @@ -413,7 +413,7 @@ object Analysis { } /** Gets the number of ref params in a formal param list */ - def getNumRefParams(params: Ast.FormalParamList) = + def getNumRefParams(params: Ast.FormalParamList): Int = params.filter(aNode => { val param = aNode._2.data param.kind == Ast.FormalParam.Ref @@ -424,7 +424,7 @@ object Analysis { queueFullOpt.getOrElse(Ast.QueueFull.Assert) /** Displays an ID value */ - def displayIdValue(value: Int) = { + def displayIdValue(value: Int): String = { val dec = value.toString val hex = Integer.toString(value, 16).toUpperCase s"($dec dec, $hex hex)" diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala index d6477520b..2f02f0e72 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala @@ -14,7 +14,7 @@ trait Analyzer extends AstStateVisitor { case None => Right(a) } - override def transUnit(a: Analysis, tu: Ast.TransUnit) = + override def transUnit(a: Analysis, tu: Ast.TransUnit): Result = visitList(a, tu.members, matchTuMember) } diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala index 32a444623..db504851f 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala @@ -9,7 +9,7 @@ trait ComponentAnalyzer extends Analyzer { override def defComponentAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Either[Error,Analysis] = { val (_, node1, _) = node val Ast.DefComponent(kind, name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala index ba50321f0..468a5ed77 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala @@ -12,7 +12,7 @@ trait EnumAnalyzer extends Analyzer { override def defEnumAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val a1 = a.copy(scopeNameList = data.name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala index 8cf78d705..af1944e65 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala @@ -9,7 +9,7 @@ trait ModuleAnalyzer extends Analyzer { override def defModuleAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Either[Error,Analysis] = { val (_, node1, _) = node val Ast.DefModule(name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala index fc3ca35ae..e3ec17250 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala @@ -9,7 +9,7 @@ trait TopologyAnalyzer extends Analyzer { override def defTopologyAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): Either[Error,Analysis] = { val (_, node1, _) = node val Ast.DefTopology(name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala index 234cbe9b4..72eaaff5c 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala @@ -11,7 +11,7 @@ trait TypeExpressionAnalyzer with TopologyAnalyzer { - def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { + def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Result = { val (_, node1, _) = node val data = node1.data opt(exprNode)(a, data.value) @@ -42,12 +42,12 @@ trait TypeExpressionAnalyzer } yield a } - def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]) = matchTypeNameNode(a, node) + def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Out = matchTypeNameNode(a, node) override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString): Out = opt(exprNode)(a, tn.size) - override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -57,7 +57,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = { + override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -70,13 +70,13 @@ trait TypeExpressionAnalyzer } yield a } - override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]) = { + override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { val (_, node1, _) = node val data = node1.data exprNode(a, data.value) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -86,7 +86,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -95,7 +95,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -104,25 +104,25 @@ trait TypeExpressionAnalyzer } yield a } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Result = visitList(a, e.elts, exprNode) - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,State] = for { a <- exprNode(a, e.e1) a <- exprNode(a, e.e2) } yield a - override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot) = exprNode(a, e.e) + override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot): Result = exprNode(a, e.e) - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = exprNode(a, e.e) + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Result = exprNode(a, e.e) - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Result = visitList(a, e.members, structMemberNode) - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = exprNode(a, e.e) + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Result = exprNode(a, e.e) - override def specCommandAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCommand]]) = { + override def specCommandAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCommand]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -133,7 +133,7 @@ trait TypeExpressionAnalyzer } override def specConnectionGraphAnnotatedNode( - a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]) = { + a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]): Out = { def connection(a: Analysis, connection: Ast.SpecConnectionGraph.Connection): Result = { for { a <- opt(exprNode)(a, connection.fromIndex) @@ -148,7 +148,7 @@ trait TypeExpressionAnalyzer } } - override def specEventAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecEvent]]) = { + override def specEventAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecEvent]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -158,12 +158,12 @@ trait TypeExpressionAnalyzer } yield a } - override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]) = { + override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]): Result = { val data = aNode._2.data exprNode(a, data.phase) } - override def specInternalPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecInternalPort]]) = { + override def specInternalPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecInternalPort]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -172,7 +172,7 @@ trait TypeExpressionAnalyzer } yield a } - override def specParamAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecParam]]) = { + override def specParamAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecParam]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -184,7 +184,7 @@ trait TypeExpressionAnalyzer } yield a } - override def specPortInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { + override def specPortInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { val (_, node1, _) = node val data = node1.data data match { @@ -197,7 +197,7 @@ trait TypeExpressionAnalyzer } } - override def specTlmChannelAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = { + override def specTlmChannelAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]): Either[Error,State] = { def limit(a: Analysis, value: Ast.SpecTlmChannel.Limit) = { val (_, e) = value exprNode(a, e) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala index 2cd56fe0e..57afa244c 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala @@ -24,7 +24,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { /** A use of a type definition */ def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = default(a) - override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = { + override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]): Either[Error,State] = { val (_, node1, _) = node val data = node1.data for { @@ -33,7 +33,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } yield a } - override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot) = { + override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot): Result = { def nameOpt(e: Ast.Expr, qualifier: List[Name.Unqualified]): Option[Name.Qualified] = { e match { case Ast.ExprIdent(id) => { @@ -51,19 +51,19 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def exprIdentNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprIdent) = { + override def exprIdentNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprIdent): Result = { val use = Name.Qualified(Nil, e.value) constantUse(a, node, use) } - override def specCompInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCompInstance]]) = { + override def specCompInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCompInstance]]): Result = { val (_, node1, _) = node val data = node1.data qualIdentNode (componentInstanceUse) (a, data.instance) } override def specConnectionGraphAnnotatedNode( - a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]) = { + a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]): Out = { def connection(a: Analysis, connection: Ast.SpecConnectionGraph.Connection): Result = { for { a <- portInstanceIdentifierNode(a, connection.fromPort) @@ -83,7 +83,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { + override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { val (_, node, _) = aNode val data = node.data data match { @@ -115,13 +115,13 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]) = { + override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]): Result = { val (_, node1, _) = node val data = node1.data qualIdentNode(topologyUse)(a, data.top) } - override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent) = { + override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent): Result = { val use = Name.Qualified.fromQualIdent(tn.name.data) typeUse(a, node, use) } diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala index 0d999636c..f7bb4e71c 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala @@ -13,7 +13,7 @@ object CheckComponentDefs override def defComponentAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Either[Error,Analysis] = { val a1 = a.copy(component = Some(Component(aNode))) for { a <- super.defComponentAnnotatedNode(a1, aNode) @@ -28,7 +28,7 @@ object CheckComponentDefs override def specCommandAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ) = { + ): Either[Error,Analysis] = { val data = aNode._2.data for { opcodeOpt <- a.getIntValueOpt(data.opcode) @@ -41,7 +41,7 @@ object CheckComponentDefs override def specEventAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ) = { + ): Either[Error,Analysis] = { val data = aNode._2.data for { idOpt <- a.getIntValueOpt(data.id) @@ -54,7 +54,7 @@ object CheckComponentDefs override def specInternalPortAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ) = { + ): Either[Error,Analysis] = { val data = aNode._2.data for { instance <- PortInstance.fromSpecInternalPort(a, aNode) @@ -66,7 +66,7 @@ object CheckComponentDefs override def specParamAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ) = { + ): Either[Error,Analysis] = { val data = aNode._2.data val component = a.component.get for { @@ -83,7 +83,7 @@ object CheckComponentDefs override def specPortInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ) = { + ): Either[Error,Analysis] = { for { instance <- PortInstance.fromSpecPortInstance(a, aNode) component <- a.component.get.addPortInstance(instance) @@ -94,7 +94,7 @@ object CheckComponentDefs override def specPortMatchingAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ) = { + ): Out = { val component = a.component.get val list = aNode :: component.specPortMatchingList val component1 = component.copy(specPortMatchingList = list) @@ -104,7 +104,7 @@ object CheckComponentDefs override def specTlmChannelAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ) = { + ): Either[Error,Analysis] = { val data = aNode._2.data for { idOpt <- a.getIntValueOpt(data.id) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala index caf4d0ad9..c4e935922 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala @@ -12,7 +12,7 @@ object CheckComponentInstanceDefs override def defComponentInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ) = + ): Either[Error,Analysis] = for { ci <- ComponentInstance.fromDefComponentInstance( a, @@ -33,7 +33,7 @@ object CheckComponentInstanceDefs override def specInitAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]] - ) = + ): Either[Error,Analysis] = for { is <- InitSpecifier.fromNode(a, aNode) ci <- a.componentInstance.get.addInitSpecifier(is) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala index 8bf3fdd15..1729b71fa 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala @@ -7,10 +7,10 @@ import fpp.compiler.util._ * and default values */ object CheckExprTypes extends UseAnalyzer { - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = visitUse(a, node) - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -29,7 +29,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { val (_, node,_) = aNode if (!a.typeMap.contains(node.id)) { val data = node.data @@ -42,7 +42,7 @@ object CheckExprTypes extends UseAnalyzer { else Right(a) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -60,7 +60,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { + override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -72,7 +72,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -90,7 +90,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = { + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Either[Error,Analysis] = { val loc = Locations.get(node.id) val emptyListError = SemanticError.EmptyArray(loc) for { @@ -99,7 +99,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> Type.AnonArray(Some(e.elts.size), t)) } - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = { + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,State] = { val loc = Locations.get(node.id) for { a <- super.exprBinopNode(a, node, e) @@ -108,24 +108,24 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> t) } - override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool) = + override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool): Out = Right(a.assignType(node -> Type.Boolean)) - override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat) = + override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat): Out = Right(a.assignType(node -> Type.F64)) - override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt) = + override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt): Out = Right(a.assignType(node -> Type.Integer)) - override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString) = + override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString): Out = Right(a.assignType(node -> Type.String(None))) - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = { + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Either[Error,Analysis] = { for (a <- super.exprParenNode(a, node, e)) yield a.assignType(node -> a.typeMap(e.e.id)) } - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = { + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Either[Error,State] = { def getName(member: Ast.StructMember) = member.name for { _ <- Analysis.checkForDuplicateStructMember(getName)(e.members) @@ -143,7 +143,7 @@ object CheckExprTypes extends UseAnalyzer { } } - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = { + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Either[Error,Analysis] = { val loc = Locations.get(node.id) for { a <- super.exprUnopNode(a, node, e) @@ -154,7 +154,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> t) } - override def specCommandAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]]) = { + override def specCommandAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -165,7 +165,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specEventAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]) = { + override def specEventAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -176,7 +176,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]) = { + override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -186,7 +186,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specInternalPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]]) = { + override def specInternalPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for { @@ -196,7 +196,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specParamAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]]) = { + override def specParamAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data def checkDefault (a: Analysis) (default: AstNode[Ast.Expr]) = { @@ -215,7 +215,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { + override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { val (_, node, _) = aNode val data = node.data data match { @@ -230,7 +230,7 @@ object CheckExprTypes extends UseAnalyzer { } } - override def specTlmChannelAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = { + override def specTlmChannelAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data def checkLimitExpr (a: Analysis) (e: AstNode[Ast.Expr]): Result.Result[Unit] = { @@ -268,7 +268,7 @@ object CheckExprTypes extends UseAnalyzer { a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ) = + ): Either[Error,State] = for { a <- super.typeNameStringNode(a, node, tn) _ <- convertNodeToNumericOpt(a, tn.size) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala index dbe6f5873..3e3e38f35 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala @@ -9,7 +9,7 @@ object CheckPortDefs with ModuleAnalyzer { - override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data for (_ <- Analysis.checkForDuplicateParameter(data.params)) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala index b5ae915e4..183e4a96f 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala @@ -9,37 +9,37 @@ object CheckSpecLocs with ModuleAnalyzer { - override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { + override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Constant, name, node) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Port, name, node) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala index 5ac95b99a..2aa7a6625 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala @@ -13,7 +13,7 @@ object CheckTopologyDefs override def defTopologyAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): Either[Error,Analysis] = { val symbol = Symbol.Topology(aNode) a.topologyMap.get(symbol) match { case None => @@ -44,7 +44,7 @@ object CheckTopologyDefs override def specCompInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ) = { + ): Either[Error,Analysis] = { val node = aNode._2 val visibility = node.data.visibility val instanceNode = node.data.instance @@ -62,7 +62,7 @@ object CheckTopologyDefs override def specConnectionGraphAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ) = { + ): Either[Error,Analysis] = { for { topology <- aNode._2.data match { case direct: Ast.SpecConnectionGraph.Direct => @@ -82,7 +82,7 @@ object CheckTopologyDefs override def specTopImportAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ) = { + ): Either[Error,Analysis] = { val node = aNode._2 val topNode = node.data.top for { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala index f1d50071a..7def373dd 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala @@ -8,7 +8,7 @@ import fpp.compiler.util._ * default value expressions are still unevaluated. */ object CheckTypeUses extends UseAnalyzer { - override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { + override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]): Result = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { val t = Type.AbsType(aNode) val node = aNode._2 @@ -17,7 +17,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = for (a <- super.defArrayAnnotatedNode(a, aNode)) yield { @@ -31,7 +31,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data @@ -68,7 +68,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val data = node.data @@ -97,12 +97,12 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def exprNode(a: Analysis, node: AstNode[Ast.Expr]) = default(a) + override def exprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = default(a) - override def typeNameBoolNode(a: Analysis, node: AstNode[Ast.TypeName]) = + override def typeNameBoolNode(a: Analysis, node: AstNode[Ast.TypeName]): Out = Right(a.assignType(node -> Type.Boolean)) - override def typeNameFloatNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat) = { + override def typeNameFloatNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat): Out = { val t = tn.name match { case Ast.F32() => Type.F32 case Ast.F64() => Type.F64 @@ -110,7 +110,7 @@ object CheckTypeUses extends UseAnalyzer { Right(a.assignType(node -> t)) } - override def typeNameIntNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt) = { + override def typeNameIntNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt): Out = { val t = tn.name match { case Ast.I8() => Type.I8 case Ast.I16() => Type.I16 @@ -124,10 +124,10 @@ object CheckTypeUses extends UseAnalyzer { Right(a.assignType(node -> t)) } - override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString) = + override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString): Out = Right(a.assignType(node -> Type.String(tn.size))) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = visitUse(a, node) private def visitUse[T](a: Analysis, node: AstNode[T]): Result = { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala index 312398866..b29bf6a47 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala @@ -9,40 +9,40 @@ object CheckUseDefCycles extends UseAnalyzer { override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = visitUse(a, node, use) - override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { val symbol = Symbol.Array(node) visitDefPost(a, symbol, node, super.defArrayAnnotatedNode) } - override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]) = { + override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { val symbol = Symbol.Constant(node) visitDefPost(a, symbol, node, super.defConstantAnnotatedNode) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { val symbol = Symbol.Enum(node) visitDefPost(a, symbol, node, super.defEnumAnnotatedNode) } - override def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { + override def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Result = { val symbol = Symbol.EnumConstant(node) visitDefPost(a, symbol, node, super.defEnumConstantAnnotatedNode) } - override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { val symbol = Symbol.Struct(node) visitDefPost(a, symbol, node, super.defStructAnnotatedNode) } - override def defTopologyAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]]) = { + override def defTopologyAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]]): Result = { val symbol = Symbol.Topology(node) visitDefPost(a, symbol, node, super.defTopologyAnnotatedNode) } - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = visitUse(a, node, use) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = visitUse(a, node, use) private def error(a: Analysis, symbol: Symbol): Result = { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala index 68cf3e30b..ca3847a5d 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala @@ -6,13 +6,13 @@ import fpp.compiler.util._ /** Match uses to their definitions */ object CheckUses extends UseAnalyzer { - override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = visitQualIdentNode (NameGroup.ComponentInstance) (a, node) - override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = visitQualIdentNode (NameGroup.Component) (a, node) - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = { + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = { def visitExprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = { def visitExprIdent(a: Analysis, node: AstNode[Ast.Expr], name: Name.Unqualified) = { val mapping = a.nestedScope.get (NameGroup.Value) _ @@ -55,7 +55,7 @@ object CheckUses extends UseAnalyzer { visitExprNode(a, node) } - override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { + override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data for { @@ -69,7 +69,7 @@ object CheckUses extends UseAnalyzer { } yield a.copy(nestedScope = a.nestedScope.pop) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,Analysis] = { val (_, node1, _) = node val data = node1.data for { @@ -88,7 +88,7 @@ object CheckUses extends UseAnalyzer { override def defModuleAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Either[Error,Analysis] = { val node = aNode._2 val Ast.DefModule(name, members) = node.data for { @@ -106,13 +106,13 @@ object CheckUses extends UseAnalyzer { yield a.copy(nestedScope = a.nestedScope.pop) } - override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = visitQualIdentNode (NameGroup.Port) (a, node) - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = visitQualIdentNode (NameGroup.Topology) (a, node) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = { + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = { val data = node.data data match { case Ast.TypeNameQualIdent(qualIdentNode) => for { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala index b904e9332..200e08b30 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala @@ -15,7 +15,7 @@ object EnterSymbols override def defAbsTypeAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -28,7 +28,7 @@ object EnterSymbols override def defArrayAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -41,7 +41,7 @@ object EnterSymbols override def defComponentAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -73,7 +73,7 @@ object EnterSymbols override def defComponentInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -86,7 +86,7 @@ object EnterSymbols override def defConstantAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -99,7 +99,7 @@ object EnterSymbols override def defEnumAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -130,7 +130,7 @@ object EnterSymbols override def defEnumConstantAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -143,7 +143,7 @@ object EnterSymbols override def defModuleAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val Ast.DefModule(name, members) = node.data val oldScopeNameList = a.scopeNameList @@ -207,7 +207,7 @@ object EnterSymbols override def defPortAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -220,7 +220,7 @@ object EnterSymbols override def defStructAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -233,7 +233,7 @@ object EnterSymbols override def defTopologyAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): Either[Error,Analysis] = { val (_, node, _) = aNode val data = node.data val name = data.name diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala index 30f2d7183..322b1cff0 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala @@ -6,10 +6,10 @@ import fpp.compiler.util._ /** Compute the values of constants symbols and expressions */ object EvalConstantExprs extends UseAnalyzer { - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = visitUse(a, node) - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { val (_, node,_) = aNode if (!a.valueMap.contains(node.id)) { val data = node.data @@ -22,7 +22,7 @@ object EvalConstantExprs extends UseAnalyzer { else Right(a) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { def checkForDuplicateValue( a: Analysis, ids: List[AstNode.Id], @@ -47,7 +47,7 @@ object EvalConstantExprs extends UseAnalyzer { } yield a } - override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { + override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Result = { val (_, node, _) = aNode if (!a.valueMap.contains(node.id)) { node.data.value match { @@ -72,7 +72,7 @@ object EvalConstantExprs extends UseAnalyzer { else Right(a) } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Either[Error,Analysis] = for (a <- super.exprArrayNode(a, node, e)) yield { val eltType = a.typeMap(node.id) match { @@ -88,7 +88,7 @@ object EvalConstantExprs extends UseAnalyzer { a.assignValue(node -> v) } - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,Analysis] = for { a <- super.exprBinopNode(a, node, e) v <- e.op match { @@ -99,7 +99,7 @@ object EvalConstantExprs extends UseAnalyzer { } } yield a.assignValue(node -> v) - override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool) = { + override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool): Out = { val b = e.value match { case Ast.LiteralBool.True => true case Ast.LiteralBool.False => false @@ -109,29 +109,29 @@ object EvalConstantExprs extends UseAnalyzer { } - override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat) = { + override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat): Out = { val v = Value.Float(e.value.toDouble, Type.Float.F64) Right(a.assignValue(node -> v)) } - override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt) = { + override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt): Out = { val bigInt = if (e.value.startsWith("0x") || e.value.startsWith("0X")) BigInt(e.value.substring(2, e.value.length), 16) else BigInt(e.value) val v = Value.Integer(bigInt) Right(a.assignValue(node -> v)) } - override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString) = { + override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString): Out = { val v = Value.String(e.value) Right(a.assignValue(node -> v)) } - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = { + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Either[Error,Analysis] = { for (a <- super.exprParenNode(a, node, e)) yield a.assignValue(node -> a.valueMap(e.e.id)) } - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Either[Error,Analysis] = for (a <- super.exprStructNode(a, node, e)) yield { def visitor(members: Value.Struct.Members, node: AstNode[Ast.StructMember]): Value.Struct.Members = { @@ -145,7 +145,7 @@ object EvalConstantExprs extends UseAnalyzer { a.assignValue(node -> v) } - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = { + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Either[Error,Analysis] = { for (a <- super.exprUnopNode(a, node, e)) yield { val v = a.neg(e.e.id) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala index 015fbe6c2..7d6622665 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala @@ -10,7 +10,7 @@ object EvalImpliedEnumConsts with ComponentAnalyzer { - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Out = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala index f295c3733..8158c6c7f 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala @@ -11,13 +11,13 @@ object FinalizeTypeDefs override def exprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = default(a) - override def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]) = { + override def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Either[Error,State] = { val t1 = a.typeMap(node.id) for (t2 <- TypeVisitor.ty(a, t1)) yield if (t1 != t2) a.assignType(node -> t2) else a } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { val symbol = Symbol.Array(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val node = aNode._2 @@ -66,7 +66,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { val symbol = Symbol.Enum(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode @@ -83,7 +83,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { val symbol = Symbol.Struct(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode @@ -156,7 +156,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def transUnit(a: Analysis, tu: Ast.TransUnit) = + override def transUnit(a: Analysis, tu: Ast.TransUnit): Result = super.transUnit(a.copy(visitedSymbolSet = Set()), tu) private def visitIfNeeded[T] @@ -175,21 +175,21 @@ object FinalizeTypeDefs type Out = Result.Result[Type] - override def default(a: Analysis, t: Type) = Right(t) + override def default(a: Analysis, t: Type): Out = Right(t) - override def array(a: Analysis, t: Type.Array) = + override def array(a: Analysis, t: Type.Array): Either[Error,Type] = for (a <- defArrayAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def anonArray(a: Analysis, t: Type.AnonArray) = + override def anonArray(a: Analysis, t: Type.AnonArray): Either[Error,Type.AnonArray] = for (eltType <- ty(a, t.eltType)) yield Type.AnonArray(t.size, eltType) - override def enumeration(a: Analysis, t: Type.Enum) = + override def enumeration(a: Analysis, t: Type.Enum): Either[Error,Type] = for (a <- defEnumAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def string(a: Analysis, t: Type.String) = + override def string(a: Analysis, t: Type.String): Out = t.size match { case Some(e) => { val id = e.id @@ -206,11 +206,11 @@ object FinalizeTypeDefs case None => Right(t) } - override def struct(a: Analysis, t: Type.Struct) = + override def struct(a: Analysis, t: Type.Struct): Either[Error,Type] = for (a <- defStructAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def anonStruct(a: Analysis, t: Type.AnonStruct) = { + override def anonStruct(a: Analysis, t: Type.AnonStruct): Either[Error,Type.AnonStruct] = { def visitor(member: Type.Struct.Member): Result.Result[Type.Struct.Member] = for (memberType <- ty(a, member._2)) yield member._1 -> memberType for (members <- Result.map(t.members.toList, visitor)) diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala index 3e948d766..7b30b8fbd 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala @@ -9,7 +9,7 @@ object BuildSpecLocMap extends ModuleAnalyzer { override def specLocAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecLoc]] - ) = { + ): Out = { val specNode = node._2 val spec = specNode.data val symbol = spec.symbol diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala index 2741e7eff..51d2edb7a 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala @@ -10,7 +10,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def defComponentAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Result = { val (_, node, _) = aNode val data = node.data val d = data.kind match { @@ -27,7 +27,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def defModuleAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Result = { val (_, node, _) = aNode val data = node.data visitList(s, data.members, matchModuleMember) @@ -36,7 +36,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def specPortInstanceAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ) = { + ): Out = { val (_, node, _) = aNode node.data match { case general: Ast.SpecPortInstance.General => @@ -49,7 +49,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { } } - override def transUnit(s: State, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit): Result = visitList(s, tu.members, matchTuMember) } diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/FrameworkDependency.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/FrameworkDependency.scala index c7afaa3a3..27edc11d4 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/FrameworkDependency.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/FrameworkDependency.scala @@ -23,7 +23,7 @@ object FrameworkDependency { FwComp ).zipWithIndex.toMap - def sort(s: Seq[FrameworkDependency]) = + def sort(s: Seq[FrameworkDependency]): Seq[FrameworkDependency] = s.sortWith((a, b) => orderMap(a) < orderMap(b)) } diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala index 9f4c57645..58556d158 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala @@ -8,13 +8,13 @@ import fpp.compiler.util._ /** Map uses to locations */ object MapUsesToLocs extends UseAnalyzer { - override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = analyzeUse(a, Ast.SpecLoc.ComponentInstance, use) - override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = analyzeUse(a, Ast.SpecLoc.Component, use) - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Either[Error,State] = for { // Analyze as a constant a <- analyzeUse(a, Ast.SpecLoc.Constant, use) @@ -28,13 +28,13 @@ object MapUsesToLocs extends UseAnalyzer { } } yield a - override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = analyzeUse(a, Ast.SpecLoc.Port, use) - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = analyzeUse(a, Ast.SpecLoc.Topology, use) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = analyzeUse(a, Ast.SpecLoc.Type, use) private def analyzeUse(a: Analysis, kind: Ast.SpecLoc.Kind, use: Name.Qualified): Result = { diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala index 351c9d931..495aba7ff 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala @@ -23,7 +23,7 @@ final object Command { aNode: Ast.Annotated[AstNode[Ast.SpecCommand]], kind: NonParam.Kind ) extends Command { - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) def getName = aNode._2.data.name } @@ -44,8 +44,8 @@ final object Command { aNode: Ast.Annotated[AstNode[Ast.SpecParam]], kind: Param.Kind, ) extends Command { - def getLoc = Locations.get(aNode._2.id) - def getName = { + def getLoc: Location = Locations.get(aNode._2.id) + def getName: String = { val paramName = aNode._2.data.name.toUpperCase kind match { case Param.Get => s"${paramName}_PARAM_GET" diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala index 8af187699..a7ac2e359 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala @@ -341,7 +341,7 @@ case class Component( } /** Complete a component definition */ - def complete = for { + def complete: Either[Error,Component] = for { c <- this.constructPortMatchingList _ <- c.checkValidity } yield c @@ -419,10 +419,10 @@ object Component { instance2: PortInstance.General ) { - override def toString = s"match $instance1 with $instance2" + override def toString: String = s"match $instance1 with $instance2" /** Gets the location of a port matching */ - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala index 3069157bd..65820e152 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala @@ -41,7 +41,7 @@ final case class ComponentInstance( /** Gets the location of the component instance */ def getLoc: Location = Locations.get(aNode._2.id) - override def compare(that: ComponentInstance) = + override def compare(that: ComponentInstance): Int = this.qualifiedName.toString.compare(that.qualifiedName.toString) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala b/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala index fc8228f19..343017a55 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala @@ -11,7 +11,7 @@ case class Connection( to: Connection.Endpoint ) extends Ordered[Connection] { - override def toString = s"${from.toString} -> ${to.toString}" + override def toString: String = s"${from.toString} -> ${to.toString}" /** Checks the types of a connection */ def checkTypes: Result.Result[Unit] = { @@ -50,7 +50,7 @@ case class Connection( } /** Compare two connections */ - def compare(that: Connection) = { + def compare(that: Connection): Int = { val fromCompare = this.from.compare(that.from) if (fromCompare != 0) fromCompare else this.to.compare(that.to) @@ -60,7 +60,7 @@ case class Connection( def getLoc: Location = from.loc /** Get this endpoint of a port connection at a port instance */ - def getThisEndpoint(pi: PortInstance) = { + def getThisEndpoint(pi: PortInstance): Connection.Endpoint = { import PortInstance.Direction._ pi.getDirection.get match { case Input => to @@ -69,7 +69,7 @@ case class Connection( } /** Get the other endpoint of a port connection at a port instance */ - def getOtherEndpoint(pi: PortInstance) = { + def getOtherEndpoint(pi: PortInstance): Connection.Endpoint = { import PortInstance.Direction._ pi.getDirection.get match { case Input => from @@ -103,12 +103,12 @@ object Connection { portNumber: Option[Int] = None ) extends Ordered[Endpoint] { - override def toString = portNumber match { + override def toString: String = portNumber match { case Some(n) => s"${port.toString}[${n.toString}]" case None => port.toString } - override def compare(that: Endpoint) = { + override def compare(that: Endpoint): Int = { val name1 = this.port.getQualifiedName.toString val name2 = that.port.getQualifiedName.toString val nameCompare = name1.compare(name2) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ConnectionPattern.scala b/compiler/lib/src/main/scala/analysis/Semantics/ConnectionPattern.scala index d2b2e2425..abd85d394 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ConnectionPattern.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ConnectionPattern.scala @@ -15,7 +15,7 @@ case class ConnectionPattern( targets: Set[(ComponentInstance, Location)] ) { - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Event.scala b/compiler/lib/src/main/scala/analysis/Semantics/Event.scala index c8cc0ef21..f2b7da795 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Event.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Event.scala @@ -14,7 +14,7 @@ final case class Event( def getName = aNode._2.data.name /** Gets the location of the event */ - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Format.scala b/compiler/lib/src/main/scala/analysis/Semantics/Format.scala index ff644df81..2965f9c4d 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Format.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Format.scala @@ -18,7 +18,7 @@ object Format { sealed trait Field extends Positional { def isInteger = false def isRational = false - final def isNumeric = isInteger || isRational + final def isNumeric: Boolean = isInteger || isRational } object Field { @@ -89,7 +89,8 @@ object Format { case prefix ~ fields => Format(prefix, fields.map({ case field ~ string => (field, string) })) } - def parseAllInput[T](p: Parser[T]) = new Parser[T] { + def parseAllInput[T](p: Parser[T]): parseAllInput[T] = new parseAllInput[T](p) + class parseAllInput[T](p: Parser[T]) extends Parser[T] { def dropWhile(in: Input, p: Char => Boolean): Input = { if (in.atEnd) in else if (p(in.first)) dropWhile(in.rest, p) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/InitSpecifier.scala b/compiler/lib/src/main/scala/analysis/Semantics/InitSpecifier.scala index d8102253c..b63c50894 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/InitSpecifier.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/InitSpecifier.scala @@ -10,7 +10,7 @@ final case class InitSpecifier( ) { /** Gets the location for this init specifier */ - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Name.scala b/compiler/lib/src/main/scala/analysis/Semantics/Name.scala index 682050053..923ffb082 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Name.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Name.scala @@ -14,7 +14,7 @@ object Name { ) { /** Convert a qualified name to a string */ - override def toString = { + override def toString: String = { def f(s1: String, s2: String) = s1 ++ "." ++ s2 def convertQualifier = qualifier match { case Nil => "" @@ -24,7 +24,7 @@ object Name { } /** Convert a qualified name to an identifier list */ - def toIdentList = (base :: qualifier).reverse + def toIdentList: List[Unqualified] = (base :: qualifier).reverse /** Computes a short qualified name * Deletes the longest prefix provided by the enclosing scope */ @@ -46,10 +46,10 @@ object Name { object Qualified { /** Create a qualified name from a string */ - def fromString(s: String) = fromIdentList(s.split(".").toList) + def fromString(s: String): Qualified = fromIdentList(s.split(".").toList) /** Create a qualified name A.B.C from an identifer list [ A, B, C ] */ - def fromIdentList(il: List[Ast.Ident]) = { + def fromIdentList(il: List[Ast.Ident]): Qualified = { il.reverse match { case head :: tail => Qualified(tail.reverse, head) case _ => throw new InternalError("empty identifier list") @@ -57,10 +57,10 @@ object Name { } /** Create a qualified name from an identifier */ - def fromIdent(id: Ast.Ident) = Qualified(Nil, id) + def fromIdent(id: Ast.Ident): Qualified = Qualified(Nil, id) /** Create a qualified name from a qualified identifier */ - def fromQualIdent(qualIdent: Ast.QualIdent) = + def fromQualIdent(qualIdent: Ast.QualIdent): Qualified = fromIdentList(qualIdent.toIdentList) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/NameGroup.scala b/compiler/lib/src/main/scala/analysis/Semantics/NameGroup.scala index 8eee3dacc..9c66aba68 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/NameGroup.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/NameGroup.scala @@ -11,7 +11,7 @@ object NameGroup { case object Type extends NameGroup case object Value extends NameGroup - val groups = List( + val groups: List[NameGroup] = List( ComponentInstance, Component, Port, diff --git a/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala b/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala index 8d0defc1e..26573a5d2 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala @@ -28,9 +28,9 @@ private case class NameSymbolMapImpl(map: Map[Name.Unqualified,Symbol] = Map()) extends NameSymbolMap { - def apply(name: Name.Unqualified) = map(name) + def apply(name: Name.Unqualified): Symbol = map(name) - def put(name: Name.Unqualified, symbol: Symbol) = { + def put(name: Name.Unqualified, symbol: Symbol): Result.Result[NameSymbolMap] = { map.get(name) match { case Some(prevSymbol) => { val loc = symbol.getLoc @@ -41,6 +41,6 @@ private case class NameSymbolMapImpl(map: Map[Name.Unqualified,Symbol] = Map()) } } - def get(name: Name.Unqualified) = map.get(name) + def get(name: Name.Unqualified): Option[Symbol] = map.get(name) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala b/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala index 0481f7bff..6e6c57aa9 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala @@ -37,30 +37,30 @@ private case class NestedScopeImpl(scopes: List[Scope] = List(Scope.empty)) extends NestedScope { - def apply (nameGroup: NameGroup) (name: Name.Unqualified) = get(nameGroup)(name) match { + def apply (nameGroup: NameGroup) (name: Name.Unqualified): Symbol = get(nameGroup)(name) match { case Some(symbol) => symbol case _ => throw new InternalError(s"could not find symbol for name ${name}") } - def splitScopes = scopes match { + def splitScopes: (Scope, List[Scope]) = scopes match { case head :: tail => (head, tail) case _ => throw new InternalError("empty scope stack") } - def push(scope: Scope) = NestedScopeImpl(scope :: this.scopes) + def push(scope: Scope): NestedScopeImpl = NestedScopeImpl(scope :: this.scopes) - def pop = { + def pop: NestedScopeImpl = { val (_, tail) = splitScopes NestedScopeImpl(tail) } - def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol) = { + def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol): Either[Error,NestedScopeImpl] = { val (head, tail) = splitScopes for (scope <- head.put(nameGroup)(name, symbol)) yield NestedScopeImpl(scope :: tail) } - def get (nameGroup: NameGroup) (name: Name.Unqualified) = { + def get (nameGroup: NameGroup) (name: Name.Unqualified): Option[Symbol] = { def helper(scopes: List[Scope]): Option[Symbol] = scopes match { case Nil => None diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Param.scala b/compiler/lib/src/main/scala/analysis/Semantics/Param.scala index 90246ce0f..091f22755 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Param.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Param.scala @@ -16,7 +16,7 @@ final case class Param( def getName = aNode._2.data.name /** Gets the location of the parameter */ - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala index 49ef84bb1..27f26bbe1 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala @@ -45,7 +45,7 @@ final object PortInstance { override def toString = "serial" } /** Show a type option */ - def show(typeOpt: Option[Type]) = typeOpt match { + def show(typeOpt: Option[Type]): String = typeOpt match { case Some(t) => t.toString case None => "none" } @@ -69,7 +69,7 @@ final object PortInstance { override def toString = "output" } /** Show a direction option */ - def show(dirOpt: Option[Direction]) = dirOpt match { + def show(dirOpt: Option[Direction]): String = dirOpt match { case Some(t) => t.toString case None => "none" } @@ -108,7 +108,7 @@ final object PortInstance { ty: Type, ) extends PortInstance { - override def getDirection = kind match { + override def getDirection: Option[Direction] = kind match { case General.Kind.Output => Some(Direction.Output) case _ => Some(Direction.Input) } @@ -117,7 +117,7 @@ final object PortInstance { override def getNodeId = aNode._2.id - override def getType = Some(ty) + override def getType: Some[Type] = Some(ty) override def getUnqualifiedName = specifier.name @@ -130,7 +130,7 @@ final object PortInstance { symbol: Symbol.Port ) extends PortInstance { - override def getDirection = { + override def getDirection: Some[Direction] = { import Ast.SpecPortInstance._ val direction = specifier.kind match { case CommandRecv => Direction.Input @@ -141,7 +141,7 @@ final object PortInstance { override def getNodeId = aNode._2.id - override def getType = Some(Type.DefPort(symbol)) + override def getType: Some[Type.DefPort] = Some(Type.DefPort(symbol)) override def getUnqualifiedName = specifier.name @@ -157,7 +157,7 @@ final object PortInstance { override def getUnqualifiedName = aNode._2.data.name - override def requireConnectionAt(loc: Location) = Left( + override def requireConnectionAt(loc: Location): Result.Result[Unit] = Left( SemanticError.InvalidPortKind( loc, "cannot connect to internal port", diff --git a/compiler/lib/src/main/scala/analysis/Semantics/PortInstanceIdentifier.scala b/compiler/lib/src/main/scala/analysis/Semantics/PortInstanceIdentifier.scala index fa3fd3a46..ba6d4e42e 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/PortInstanceIdentifier.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/PortInstanceIdentifier.scala @@ -14,14 +14,14 @@ case class PortInstanceIdentifier( override def toString = getQualifiedName.toString /** Gets the qualified name */ - def getQualifiedName = { + def getQualifiedName: Name.Qualified = { val componentName = componentInstance.qualifiedName val identList = componentName.toIdentList Name.Qualified.fromIdentList(identList :+ portInstance.getUnqualifiedName) } /** Gets the unqualified name */ - def getUnqualifiedName = { + def getUnqualifiedName: Name.Qualified = { val componentName = componentInstance.getUnqualifiedName val portName = portInstance.getUnqualifiedName val identList = List(componentName, portName) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/MatchedPortNumbering.scala b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/MatchedPortNumbering.scala index 998dd8502..87946ac9f 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/MatchedPortNumbering.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/MatchedPortNumbering.scala @@ -100,7 +100,7 @@ object MatchedPortNumbering { map1: ConnectionMap, pi2: PortInstance, map2: ConnectionMap - ) = { + ): State = { // Compute the used port numbers val usedPortNumbers = t.getUsedPortNumbers(pi1, map1.values) ++ t.getUsedPortNumbers(pi2, map2.values) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala index d1db6524c..9e710b974 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala @@ -172,44 +172,44 @@ object PatternResolver { cmdResponseOut: PortInstanceIdentifier ) - def getCmdRegIn = getGeneralPort( + def getCmdRegIn: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, "command reg", PortInstance.Direction.Input, "Fw.CmdReg" ) - def getCmdOut = getGeneralPort( + def getCmdOut: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, "command send", PortInstance.Direction.Output, "Fw.Cmd" ) - def getCmdResponseIn = getGeneralPort( + def getCmdResponseIn: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, "command resp", PortInstance.Direction.Input, "Fw.CmdResponse" ) - def getCmdRegOut(targetUse: (ComponentInstance, Location)) = + def getCmdRegOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.CommandReg) - def getCmdIn(targetUse: (ComponentInstance, Location)) = + def getCmdIn(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.CommandRecv) - def getCmdResponseOut(targetUse: (ComponentInstance, Location)) = + def getCmdResponseOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.CommandResp) - override def resolveSource = + override def resolveSource: Either[Error,Source] = for { cmdRegIn <- getCmdRegIn cmdOut <- getCmdOut cmdResponseIn <- getCmdResponseIn } yield Source(cmdRegIn, cmdOut, cmdResponseIn) - override def resolveTarget(targetUse: (ComponentInstance, Location)) = + override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Target] = for { cmdRegOut <- getCmdRegOut(targetUse) cmdIn <- getCmdIn(targetUse) @@ -245,14 +245,14 @@ object PatternResolver { type Target = PortInstanceIdentifier - override def resolveSource = getGeneralPort( + override def resolveSource: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, kind.toString, PortInstance.Direction.Input, portTypeName ) - override def resolveTarget(targetUse: (ComponentInstance, Location)) = + override def resolveTarget(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, kind) override def getConnectionsForTarget( @@ -331,9 +331,9 @@ object PatternResolver { } yield Health.PingPorts(pingIn, pingOut) - override def resolveSource = getPingPorts(pattern.source) + override def resolveSource: Either[Error,Health.PingPorts] = getPingPorts(pattern.source) - override def resolveTarget(targetUse: (ComponentInstance, Location)) = + override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Health.PingPorts] = getPingPorts(targetUse) override def getConnectionsForTarget( @@ -378,32 +378,32 @@ object PatternResolver { prmSetOut: PortInstanceIdentifier ) - def getPrmGetIn = getGeneralPort( + def getPrmGetIn: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, "param get", PortInstance.Direction.Input, "Fw.PrmGet" ) - def getPrmSetIn = getGeneralPort( + def getPrmSetIn: Result.Result[PortInstanceIdentifier] = getGeneralPort( pattern.source, "param set", PortInstance.Direction.Input, "Fw.PrmSet" ) - def getPrmGetOut(targetUse: (ComponentInstance, Location)) = + def getPrmGetOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.ParamGet) - def getPrmSetOut(targetUse: (ComponentInstance, Location)) = + def getPrmSetOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.ParamSet) - override def resolveSource = for { + override def resolveSource: Either[Error,Source] = for { prmGetIn <- getPrmGetIn prmSetIn <- getPrmSetIn } yield Source(prmGetIn, prmSetIn) - override def resolveTarget(targetUse: (ComponentInstance, Location)) = + override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Target] = for { prmGetOut <- getPrmGetOut(targetUse) prmSetOut <- getPrmSetOut(targetUse) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PortNumberingState.scala b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PortNumberingState.scala index ef4b0c05d..2d3f606b4 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PortNumberingState.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PortNumberingState.scala @@ -13,7 +13,7 @@ case class PortNumberingState private ( /** Marks the next port number as used and generates * a new one */ - def usePortNumber = { + def usePortNumber: PortNumberingState = { val s = usedPortNumbers + nextPortNumber val n = PortNumberingState.getNextNumber( nextPortNumber, @@ -33,7 +33,7 @@ case class PortNumberingState private ( object PortNumberingState { /** Construct an initial state */ - def initial(usedPortNumbers: Set[Int]) = { + def initial(usedPortNumbers: Set[Int]): PortNumberingState = { val nextPortNumber = getNextNumber(0, usedPortNumbers) PortNumberingState(usedPortNumbers, nextPortNumber) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala b/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala index b42d5629c..e1a4d03f3 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala @@ -28,7 +28,7 @@ private case class ScopeImpl(map: Map[NameGroup,NameSymbolMap] = Map()) extends Scope { - def apply (nameGroup: NameGroup) (name: Name.Unqualified) = + def apply (nameGroup: NameGroup) (name: Name.Unqualified): Symbol = getNameSymbolMap(nameGroup)(name) /** Get the name-symbol map for a name group */ @@ -38,13 +38,13 @@ private case class ScopeImpl(map: Map[NameGroup,NameSymbolMap] = Map()) case None => NameSymbolMap.empty } - def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol) = { + def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol): Either[Error,ScopeImpl] = { val nsm = getNameSymbolMap(nameGroup) for (nsm <- nsm.put(name, symbol)) yield this.copy(map = this.map + (nameGroup -> nsm)) } - def get (nameGroup: NameGroup) (name: Name.Unqualified) = + def get (nameGroup: NameGroup) (name: Name.Unqualified): Option[Symbol] = getNameSymbolMap(nameGroup).get(name) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala b/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala index 312ac1eac..ef2a954f6 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala @@ -17,7 +17,7 @@ final case class TlmChannel( def getName = aNode._2.data.name /** Gets the location of the channel */ - def getLoc = Locations.get(aNode._2.id) + def getLoc: Location = Locations.get(aNode._2.id) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Topology.scala b/compiler/lib/src/main/scala/analysis/Semantics/Topology.scala index 6a069711e..54390dea1 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Topology.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Topology.scala @@ -182,7 +182,7 @@ case class Topology( def connectionExistsBetween( from: PortInstanceIdentifier, to: PortInstanceIdentifier - ) = getConnectionsBetween(from, to).size > 0 + ): Boolean = getConnectionsBetween(from, to).size > 0 /** Get the connections between two ports */ def getConnectionsBetween( @@ -199,7 +199,7 @@ case class Topology( inputConnectionMap.getOrElse(to, Set()) /** Get the connections at a port instance */ - def getConnectionsAt(pii: PortInstanceIdentifier) = { + def getConnectionsAt(pii: PortInstanceIdentifier): Set[_ <: Connection] = { import PortInstance.Direction._ val pi = pii.portInstance pi.getDirection match { @@ -213,7 +213,7 @@ case class Topology( def getUnqualifiedName = aNode._2.data.name /** Gets the set of used port numbers */ - def getUsedPortNumbers(pi: PortInstance, cs: Iterable[Connection]) = + def getUsedPortNumbers(pi: PortInstance, cs: Iterable[Connection]): Set[Int] = cs.foldLeft (Set[Int]()) ((s, c) => getPortNumber(pi, c) match { case Some(n) => s + n @@ -238,7 +238,7 @@ case class Topology( } /** Resolve the numbers in a connection */ - def resolveNumbers(c: Connection) = { + def resolveNumbers(c: Connection): Connection = { val fromNumber = getPortNumber(c.from.port.portInstance, c) val toNumber = getPortNumber(c.to.port.portInstance, c) val from = c.from.copy(portNumber = fromNumber) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala index 3ed082866..d64b6fe6b 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala @@ -2,6 +2,7 @@ package fpp.compiler.analysis import fpp.compiler.ast._ import fpp.compiler.util._ +import java.lang /** An FPP Type */ sealed trait Type { @@ -40,7 +41,7 @@ sealed trait Type { final def isNumeric: Boolean = isInt || isFloat /** Is this type convertible to type t? */ - final def isConvertibleTo(t: Type) = Type.mayBeConverted(this -> t) + final def isConvertibleTo(t: Type): Boolean = Type.mayBeConverted(this -> t) } @@ -61,7 +62,7 @@ object Type { extends Type with Primitive with Int { override def getDefaultValue: Option[Value.PrimitiveInt] = Some(Value.PrimitiveInt(0, kind)) - override def toString = kind match { + override def toString: lang.String = kind match { case PrimitiveInt.I8 => "I8" case PrimitiveInt.I16 => "I16" case PrimitiveInt.I32 => "I32" @@ -85,27 +86,27 @@ object Type { case object U64 extends Kind } - val I8 = PrimitiveInt(PrimitiveInt.I8) - val I16 = PrimitiveInt(PrimitiveInt.I16) - val I32 = PrimitiveInt(PrimitiveInt.I32) - val I64 = PrimitiveInt(PrimitiveInt.I64) - val U8 = PrimitiveInt(PrimitiveInt.U8) - val U16 = PrimitiveInt(PrimitiveInt.U16) - val U32 = PrimitiveInt(PrimitiveInt.U32) - val U64 = PrimitiveInt(PrimitiveInt.U64) + val I8: PrimitiveInt = PrimitiveInt(PrimitiveInt.I8) + val I16: PrimitiveInt = PrimitiveInt(PrimitiveInt.I16) + val I32: PrimitiveInt = PrimitiveInt(PrimitiveInt.I32) + val I64: PrimitiveInt = PrimitiveInt(PrimitiveInt.I64) + val U8: PrimitiveInt = PrimitiveInt(PrimitiveInt.U8) + val U16: PrimitiveInt = PrimitiveInt(PrimitiveInt.U16) + val U32: PrimitiveInt = PrimitiveInt(PrimitiveInt.U32) + val U64: PrimitiveInt = PrimitiveInt(PrimitiveInt.U64) /** Floating-point types */ case class Float(kind: Float.Kind) extends Type with Primitive { override def getDefaultValue: Option[Value.Float] = Some(Value.Float(0, kind)) override def isFloat = true - override def toString = kind match { + override def toString: lang.String = kind match { case Float.F32 => "F32" case Float.F64 => "F64" } } - val F32 = Float(Float.F32) - val F64 = Float(Float.F64) + val F32: Float = Float(Float.F32) + val F64: Float = Float(Float.F64) object Float { sealed trait Kind @@ -116,21 +117,21 @@ object Type { /** The Boolean type */ case object Boolean extends Type with Primitive { override def getDefaultValue: Option[Value.Boolean] = Some(Value.Boolean(false)) - override def toString = "bool" + override def toString: lang.String = "bool" override def isPromotableToArray = true } /** The type of a string */ case class String(size: Option[AstNode[Ast.Expr]]) extends Type { override def getDefaultValue: Option[Value.String] = Some(Value.String("")) - override def toString = "string" + override def toString: lang.String = "string" override def isPromotableToArray = true } /** The type of arbitrary-width integers */ case object Integer extends Type with Int { override def getDefaultValue: Option[Value.Integer] = Some(Value.Integer(0)) - override def toString = "Integer" + override def toString: lang.String = "Integer" } /** An abstract type */ @@ -139,8 +140,8 @@ object Type { node: Ast.Annotated[AstNode[Ast.DefAbsType]] ) extends Type { override def getDefaultValue: Option[Value.AbsType] = Some(Value.AbsType(this)) - override def getDefNodeId = Some(node._2.id) - override def toString = node._2.data.name + override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) + override def toString: lang.String = node._2.data.name } /** A named array type */ @@ -156,11 +157,11 @@ object Type { ) extends Type { override def getDefaultValue: Option[Value.Array] = default /** Set the size */ - def setSize(size: Array.Size) = this.copy(anonArray = anonArray.setSize(size)) + def setSize(size: Array.Size): Array = this.copy(anonArray = anonArray.setSize(size)) override def getArraySize = anonArray.getArraySize - override def getDefNodeId = Some(node._2.id) + override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) override def hasNumericMembers = anonArray.hasNumericMembers - override def toString = "array " ++ node._2.data.name + override def toString: lang.String = "array " ++ node._2.data.name } object Array { @@ -194,10 +195,10 @@ object Type { default: Option[Value.EnumConstant] = None ) extends Type { override def getDefaultValue: Option[Value.EnumConstant] = default - override def getDefNodeId = Some(node._2.id) + override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) override def isConvertibleToNumeric = true override def isPromotableToArray = true - override def toString = "enum " ++ node._2.data.name + override def toString: lang.String = "enum " ++ node._2.data.name } /** A named struct type */ @@ -214,9 +215,9 @@ object Type { formats: Struct.Formats = Map(), ) extends Type { override def getDefaultValue: Option[Value.Struct] = default - override def getDefNodeId = Some(node._2.id) + override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) override def hasNumericMembers = anonStruct.hasNumericMembers - override def toString = "struct " ++ node._2.data.name + override def toString: lang.String = "struct " ++ node._2.data.name } object Struct { @@ -256,7 +257,7 @@ object Type { eltType: Type ) extends Type { /** Set the size */ - def setSize(size: Array.Size) = this.copy(size = Some(size)) + def setSize(size: Array.Size): AnonArray = this.copy(size = Some(size)) override def getDefaultValue: Option[Value.AnonArray] = for { size <- size elt <- eltType.getDefaultValue @@ -266,7 +267,7 @@ object Type { } override def getArraySize = size override def hasNumericMembers = eltType.hasNumericMembers - override def toString = size match { + override def toString: lang.String = size match { case Some(n) => "[" ++ n.toString ++ "] " ++ eltType.toString case None => "array of " ++ eltType.toString } @@ -292,9 +293,9 @@ object Type { for (members <- defaultMembers(members.toList, Map())) yield Value.AnonStruct(members) } - override def hasNumericMembers = + override def hasNumericMembers: Boolean = members.values.forall(_.hasNumericMembers) - override def toString = { + override def toString: lang.String = { def memberToString(member: Struct.Member) = member._1 ++ ": " ++ member._2.toString members.size match { diff --git a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala index 2fbff8861..5f06d5515 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala @@ -11,7 +11,7 @@ trait TypeVisitor { def array(in: In, t: Type.Array): Out = default(in, t) - def boolean(in: In) = default(in, Type.Boolean) + def boolean(in: In): Out = default(in, Type.Boolean) def default(in: In, t: Type): Out diff --git a/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala b/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala index dacf4eab2..63f35a252 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala @@ -12,7 +12,7 @@ case class UseDefMatching( symbol: Symbol ) { - override def toString = { + override def toString: String = { val useLoc = Locations.get(nodeId) val defLoc = symbol.getLoc val defName = symbol.getUnqualifiedName diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala index e0bb5e017..9c16242bd 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala @@ -2,6 +2,7 @@ package fpp.compiler.analysis import fpp.compiler.ast._ import fpp.compiler.util._ +import java.lang /** An FPP value */ sealed trait Value { @@ -107,7 +108,7 @@ object Value { extends Value { - override def binop(op: Binop)(v: Value) = v match { + override def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result1 = op.intOp(value, value1) val result2 = if (kind1 == kind) PrimitiveInt(result1, kind) else Integer(result1) @@ -123,7 +124,7 @@ object Value { case _ => None } - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value, kind1)) case Type.Integer => Some(Integer(value)) @@ -131,11 +132,11 @@ object Value { case _ => promoteToAggregate(t) } - override def getType = Type.PrimitiveInt(kind) + override def getType: Type.PrimitiveInt = Type.PrimitiveInt(kind) - override def isZero = (value == 0) + override def isZero: scala.Boolean = (value == 0) - override def toString = value.toString + ": " + kind.toString + override def toString: lang.String = value.toString + ": " + kind.toString override def truncate: PrimitiveInt = { def truncateUnsigned(v: BigInt, shiftAmt: Int) = { @@ -163,12 +164,12 @@ object Value { /** Integer values */ case class Integer(value: BigInt) extends Value { - def fitsInU64Width = { + def fitsInU64Width: scala.Boolean = { val u64Bound = BigInt(1) << 64 (value >= - (u64Bound / 2) && value < u64Bound) } - override def binop(op: Binop)(v: Value) = v match { + override def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result = op.intOp(value, value1) Some(Integer(result)) @@ -183,7 +184,7 @@ object Value { case _ => None } - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value, kind1)) case Type.Integer => Some(Integer(value)) @@ -193,9 +194,9 @@ object Value { override def getType = Type.Integer - override def isZero = (value == 0) + override def isZero: scala.Boolean = (value == 0) - override def toString = value.toString + override def toString: lang.String = value.toString override def unary_- = Some(Integer(-value)) @@ -204,7 +205,7 @@ object Value { /** Floating-point values */ case class Float(value: Double, kind: Type.Float.Kind) extends Value { - override def binop(op: Binop)(v: Value) = v match { + override def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result = op.doubleOp(value, value1.toDouble) Some(Float(result.toFloat, Type.Float.F64)) @@ -225,18 +226,18 @@ object Value { case _ => None } - override def isZero = (Math.abs(value) < Float.EPSILON) + override def isZero: scala.Boolean = (Math.abs(value) < Float.EPSILON) - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value.intValue, kind1)) case Type.Integer => Some(Integer(value.intValue)) case Type.Float(kind1) => Some(Float(value, kind1)) case _ => promoteToAggregate(t) } - override def getType = Type.Float(kind) + override def getType: Type.Float = Type.Float(kind) - override def toString = value.toString + ": " + kind.toString + override def toString: lang.String = value.toString + ": " + kind.toString override def truncate: Value = kind match { case Type.Float.F32 => Float(value.toFloat, kind) @@ -257,26 +258,26 @@ object Value { /** Boolean values */ case class Boolean(value: scala.Boolean) extends Value { - override def convertToDistinctType(t: Type) = promoteToAggregate(t) + override def convertToDistinctType(t: Type): Option[Value] = promoteToAggregate(t) override def getType = Type.Boolean - override def toString = value.toString + override def toString: lang.String = value.toString } /** String values */ case class String(value: java.lang.String) extends Value { - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case Type.String(_) => Some(this) case _ => promoteToAggregate(t) } - override def getType = Type.String(None) + override def getType: Type.String = Type.String(None) - override def toString = "\"" + value.toString + "\"" + override def toString: lang.String = "\"" + value.toString + "\"" } @@ -305,16 +306,16 @@ object Value { yield Array(anonArray, arrayType) } - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case anonArrayType : Type.AnonArray => convertToAnonArray(anonArrayType) case arrayType : Type.Array => convertToArray(arrayType) case _ => None } - override def getType = Type.AnonArray(Some(elements.size), elements.head.getType) + override def getType: Type.AnonArray = Type.AnonArray(Some(elements.size), elements.head.getType) - override def toString = "[ " ++ elements.mkString(", ") ++ " ]" + override def toString: lang.String = "[ " ++ elements.mkString(", ") ++ " ]" override def truncate: AnonArray = AnonArray(elements.map(_.truncate)) @@ -325,7 +326,7 @@ object Value { override def getType = t - override def toString = s"value of type $t" + override def toString: lang.String = s"value of type $t" } @@ -338,7 +339,7 @@ object Value { def convertToArray(arrayType: Type.Array): Option[Value.Array] = anonArray.convertToArray(arrayType) - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case anonArrayType : Type.AnonArray => convertToAnonArray(anonArrayType) case arrayType : Type.Array => convertToArray(arrayType) @@ -347,7 +348,7 @@ object Value { override def getType = t - override def toString = anonArray.toString ++ ": " ++ t.node._2.data.name + override def toString: lang.String = anonArray.toString ++ ": " ++ t.node._2.data.name override def truncate: Array = Array(anonArray.truncate, t) @@ -356,12 +357,12 @@ object Value { /** Enum constant values */ case class EnumConstant(value: (Name.Unqualified, BigInt), t: Type.Enum) extends Value { - override def binop(op: Binop)(v: Value) = convertToRepType.binop(op)(v) + override def binop(op: Binop)(v: Value): Option[Value] = convertToRepType.binop(op)(v) /** Convert the enum to the representation type */ def convertToRepType: PrimitiveInt = PrimitiveInt(value._2, t.repType.kind) - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = convertToRepType.convertToDistinctType(t) match { case Some(v) => Some(v) case None => promoteToAggregate(t) @@ -371,7 +372,7 @@ object Value { override def isZero = convertToRepType.isZero - override def toString = value.toString ++ ": " ++ t.node._2.data.name + override def toString: lang.String = value.toString ++ ": " ++ t.node._2.data.name override def unary_- = - convertToRepType @@ -405,20 +406,20 @@ object Value { yield Struct(anonStruct, structType) } - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case anonStructType : Type.AnonStruct => convertToAnonStruct(anonStructType) case structType : Type.Struct => convertToStruct(structType) case _ => None } - override def getType = { + override def getType: Type.AnonStruct = { def f(member: Struct.Member): Type.Struct.Member = (member._1, member._2.getType) val typeMembers = members.map(f) Type.AnonStruct(typeMembers) } - override def toString = { + override def toString: lang.String = { def memberToString(member: Struct.Member) = member._1 ++ " = " ++ member._2.toString members.size match { case 0 => "{ }" @@ -443,7 +444,7 @@ object Value { anonStruct.convertToAnonStruct(anonStructType) def convertToStruct(structType: Type.Struct): Option[Value.Struct] = anonStruct.convertToStruct(structType) - override def convertToDistinctType(t: Type) = + override def convertToDistinctType(t: Type): Option[Value] = t match { case anonStructType : Type.AnonStruct => convertToAnonStruct(anonStructType) case structType : Type.Struct => convertToStruct(structType) @@ -452,7 +453,7 @@ object Value { override def getType = t - override def toString = anonStruct.toString ++ ": " ++ t.node._2.data.name + override def toString: lang.String = anonStruct.toString ++ ": " ++ t.node._2.data.name override def truncate: Struct = Struct(anonStruct.truncate, t) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala index 4a72142bf..3bf5d4f7d 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala @@ -11,7 +11,7 @@ trait ValueVisitor { def array(in: In, v: Value.Array): Out = default(in, v) - def boolean(in: In, v: Value.Boolean) = default(in, v) + def boolean(in: In, v: Value.Boolean): Out = default(in, v) def default(in: In, v: Value): Out diff --git a/compiler/lib/src/main/scala/analysis/UsedSymbols.scala b/compiler/lib/src/main/scala/analysis/UsedSymbols.scala index ab743bc2b..7c8b070fd 100644 --- a/compiler/lib/src/main/scala/analysis/UsedSymbols.scala +++ b/compiler/lib/src/main/scala/analysis/UsedSymbols.scala @@ -10,37 +10,37 @@ object UsedSymbols extends UseAnalyzer { a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) override def componentInstanceUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) override def constantUse( a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) override def topologyUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) override def typeUse( a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) override def portUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ) = addSymbol(a, node) + ): Result = addSymbol(a, node) private def addSymbol[T](a: Analysis, node: AstNode[T]) = { val symbol = a.useDefMap(node.id) diff --git a/compiler/lib/src/main/scala/ast/Ast.scala b/compiler/lib/src/main/scala/ast/Ast.scala index 328f264ce..16002d692 100644 --- a/compiler/lib/src/main/scala/ast/Ast.scala +++ b/compiler/lib/src/main/scala/ast/Ast.scala @@ -226,14 +226,14 @@ object Ast { /** An unqualified identifier */ case class Unqualified(name: Ident) extends QualIdent { - def toIdentList = List(name) + def toIdentList: List[Ident] = List(name) } /** A qualified identifier */ case class Qualified(qualifier: AstNode[QualIdent], name: AstNode[Ident]) extends QualIdent { - def toIdentList = qualifier.data.toIdentList ++ List(name.data) + def toIdentList: List[Ident] = qualifier.data.toIdentList ++ List(name.data) } @@ -255,16 +255,16 @@ object Ast { object NodeList { /** Split a qualified identifier list into qualifier and name */ - def split(nodeList: NodeList) = nodeList.reverse match { + def split(nodeList: NodeList): (List[AstNode[Ident]], AstNode[Ident]) = nodeList.reverse match { case head :: tail => (tail.reverse, head) case Nil => throw InternalError("node list should not be empty") } /** Get the qualifier */ - def qualifier(nodeList: NodeList) = split(nodeList)._1 + def qualifier(nodeList: NodeList): List[AstNode[Ident]] = split(nodeList)._1 /** Get the unqualified name*/ - def name(nodeList: NodeList) = split(nodeList)._2 + def name(nodeList: NodeList): AstNode[Ident] = split(nodeList)._2 } diff --git a/compiler/lib/src/main/scala/ast/AstNode.scala b/compiler/lib/src/main/scala/ast/AstNode.scala index 588ecfabd..79deba934 100644 --- a/compiler/lib/src/main/scala/ast/AstNode.scala +++ b/compiler/lib/src/main/scala/ast/AstNode.scala @@ -9,14 +9,14 @@ object AstNode { type Id = Int /** Create a new node with a fresh identifier */ - def create[T](data: T) = { + def create[T](data: T): AstNode[T] = { val node = AstNode(data, id) id = id + 1 node } /** Create a new node with an existing identifier */ - def create[T](data: T, id: Id) = AstNode(data, id) + def create[T](data: T, id: Id): AstNode[T] = AstNode(data, id) /** The next identifier */ private var id: Id = 0 diff --git a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala index 52d298952..052a04492 100644 --- a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala +++ b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala @@ -14,7 +14,7 @@ trait AstStateVisitor extends AstVisitor { type Result = Result.Result[State] /** Default state transformation */ - def default(s: State) = Right(s) + def default(s: State): Out = Right(s) /** Visit a list in sequence, threading state */ def visitList[T]( diff --git a/compiler/lib/src/main/scala/ast/Locations.scala b/compiler/lib/src/main/scala/ast/Locations.scala index 5c84e7b0e..92924c7b8 100644 --- a/compiler/lib/src/main/scala/ast/Locations.scala +++ b/compiler/lib/src/main/scala/ast/Locations.scala @@ -9,15 +9,15 @@ object Locations { private val map = new scala.collection.mutable.HashMap[AstNode.Id, Location] /** Put a location into the map */ - def put(id: AstNode.Id, loc: Location) = map.put(id, loc) + def put(id: AstNode.Id, loc: Location): Option[Location] = map.put(id, loc) /** Get a location from the map. Throw an InternalError if the location is not there.*/ - def get(id: AstNode.Id) = getOpt(id) match { + def get(id: AstNode.Id): Location = getOpt(id) match { case Some(loc) => loc case _ => throw new InternalError(s"unknown location for AST node ${id}") } /** Get an optional location from the map */ - def getOpt(id: AstNode.Id) = map.get(id) + def getOpt(id: AstNode.Id): Option[Location] = map.get(id) } diff --git a/compiler/lib/src/main/scala/codegen/AstWriter.scala b/compiler/lib/src/main/scala/codegen/AstWriter.scala index 5ef084e73..9fac4c917 100644 --- a/compiler/lib/src/main/scala/codegen/AstWriter.scala +++ b/compiler/lib/src/main/scala/codegen/AstWriter.scala @@ -11,7 +11,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defAbsTypeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ) = { + ): List[Line] = { val (_, node, _) = aNode lines("def abs type") ++ ident(node.data.name).map(indentIn) } @@ -19,7 +19,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defArrayAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def array") ++ @@ -35,7 +35,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defComponentAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -50,7 +50,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defComponentInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def component instance") ++ @@ -70,7 +70,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defConstantAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def constant") ++ @@ -80,7 +80,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defEnumAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def enum") ++ @@ -94,7 +94,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defModuleAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def module") ++ @@ -104,7 +104,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def port") ++ @@ -118,7 +118,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defStructAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def struct") ++ @@ -132,21 +132,21 @@ object AstWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("def topology") ++ (ident(data.name) ++ data.members.map(topologyMember).flatten).map(indentIn) } - override def default(in: Unit) = + override def default(in: Unit): Out = throw new InternalError("AstWriter: Visitor not implemented") override def exprArrayNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprArray - ) = + ): List[Line] = lines("expr array") ++ e.elts.map(exprNode).flatten.map(indentIn) @@ -154,7 +154,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprBinop - ) = + ): List[Line] = lines("expr binop") ++ (exprNode(e.e1) ++ binop(e.op) ++ exprNode(e.e2)).map(indentIn) @@ -162,7 +162,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprDot - ) = + ): List[Line] = lines("expr dot") ++ (exprNode(e.e) ++ ident(e.id.data)).map(indentIn) @@ -170,14 +170,14 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprIdent - ) = + ): List[Line] = ident(e.value) override def exprLiteralBoolNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool - ) = { + ): List[Line] = { val s = e.value match { case Ast.LiteralBool.True => "true" case Ast.LiteralBool.False => "false" @@ -189,28 +189,28 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat - ) = + ): List[Line] = lines("literal float " ++ e.value) override def exprLiteralIntNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt - ) = + ): List[Line] = lines("literal int " ++ e.value) override def exprLiteralStringNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString - ) = + ): List[Line] = addPrefix("literal string", string) (e.value) override def exprParenNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprParen - ) = + ): List[Line] = lines("expr paren") ++ exprNode(e.e).map(indentIn) @@ -218,7 +218,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprStruct - ) = + ): List[Line] = lines("expr struct") ++ e.members.map(applyToData(structMember)).flatten.map(indentIn) @@ -226,14 +226,14 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprUnop - ) = + ): List[Line] = lines("expr unop") ++ (unop(e.op) ++ exprNode(e.e)).map(indentIn) override def specCommandAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec command") ++ @@ -250,7 +250,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specCompInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec comp instance") ++ ( @@ -262,7 +262,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specConnectionGraphAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ) = { + ): Out = { def direct(g: Ast.SpecConnectionGraph.Direct) = { def connection(c: Ast.SpecConnectionGraph.Connection) = { lines("connection") ++ ( @@ -295,7 +295,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specEventAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec event") ++ @@ -312,7 +312,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specIncludeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInclude]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec include") ++ fileString(data.file.data).map(indentIn) @@ -321,7 +321,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specInternalPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec internal port") ++ @@ -336,7 +336,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specLocAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecLoc]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -351,7 +351,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specParamAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec param") ++ @@ -368,7 +368,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specPortInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ) = { + ): Out = { val (_, node, _) = aNode def general(i: Ast.SpecPortInstance.General) = { val kind = lines(s"kind ${i.kind.toString}") @@ -396,7 +396,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specPortMatchingAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec port matching") ++ @@ -409,7 +409,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specTlmChannelAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ) = { + ): List[Line] = { val (_, node, _) = aNode def update(u: Ast.SpecTlmChannel.Update) = lines(s"update ${u.toString}") @@ -440,43 +440,43 @@ object AstWriter extends AstVisitor with LineUtils { override def specTopImportAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("spec top import") ++ qualIdent(data.top.data).map(indentIn) } - override def transUnit(in: Unit, tu: Ast.TransUnit) = + override def transUnit(in: Unit, tu: Ast.TransUnit): List[Line] = tu.members.map(tuMember).flatten override def typeNameBoolNode( in: Unit, node: AstNode[Ast.TypeName] - ) = lines("bool") + ): List[Line] = lines("bool") override def typeNameFloatNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat - ) = lines(tn.name.toString) + ): List[Line] = lines(tn.name.toString) override def typeNameIntNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt - ) = lines(tn.name.toString) + ): List[Line] = lines(tn.name.toString) override def typeNameQualIdentNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent - ) = qualIdent(tn.name.data) + ): List[Line] = qualIdent(tn.name.data) override def typeNameStringNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ) = + ): List[Line] = lines("string") ++ linesOpt(addPrefix("size", exprNode), tn.size).map(indentIn) private def addPrefixNoIndent[T]( diff --git a/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala b/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala index 0fa2ea2cb..dfb044d09 100644 --- a/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala +++ b/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala @@ -15,13 +15,13 @@ object ComputeGeneratedFiles { } yield xmlFiles ++ cppFiles - def getCppFiles(tul: List[Ast.TransUnit]) = + def getCppFiles(tul: List[Ast.TransUnit]): Either[Error,List[String]] = for { s <- ComputeCppFiles.visitList(Map(), tul, ComputeCppFiles.transUnit) } yield s.toList.map(_._1) - def getXmlFiles(a: Analysis, tul: List[Ast.TransUnit]) = + def getXmlFiles(a: Analysis, tul: List[Ast.TransUnit]): Either[Error,List[String]] = for { s <- ComputeXmlFiles.visitList( XmlWriterState(a), diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala index 8ce007ab8..0bc184ca4 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala @@ -19,14 +19,14 @@ object ComputeCppFiles extends AstStateVisitor { def getConstants = "FppConstantsAc" /** Gets the C++ file name for generated topologies */ - def getTopology(baseName: String) = s"${baseName}TopologyAc" + def getTopology(baseName: String): String = s"${baseName}TopologyAc" } override def defComponentAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Result = { val node = aNode._2 val data = node.data visitList(s, data.members, matchComponentMember) @@ -35,12 +35,12 @@ object ComputeCppFiles extends AstStateVisitor { override def defConstantAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = addMappings(s, FileNames.getConstants, None) + ): Either[CodeGenError.DuplicateCppFile,Map[String,Option[Location]]] = addMappings(s, FileNames.getConstants, None) override def defModuleAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Result = { val node = aNode._2 val data = node.data visitList(s, data.members, matchModuleMember) @@ -49,14 +49,14 @@ object ComputeCppFiles extends AstStateVisitor { override def defTopologyAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): Either[CodeGenError.DuplicateCppFile,Map[String,Option[Location]]] = { val node = aNode._2 val name = node.data.name val loc = Locations.get(node.id) addMappings(s, FileNames.getTopology(name), Some(loc)) } - override def transUnit(s: State, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit): Result = visitList(s, tu.members, matchTuMember) /** Adds mappings for hpp and cppfiles */ diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala index 4a9009956..8d1d1c053 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala @@ -9,7 +9,7 @@ import fpp.compiler.util._ object ConstantCppWriter { /** Writes out constant hpp and cpp */ - def write(s: CppWriterState, tuList: List[Ast.TransUnit]) = + def write(s: CppWriterState, tuList: List[Ast.TransUnit]): Either[Error,Any] = tuList.flatMap(Visitor.transUnit(s, _)) match { case Nil => Right(()) case constantMembers => @@ -43,7 +43,7 @@ object ConstantCppWriter { override def defConstantAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = { + ): List[CppDoc.Member.Lines] = { val node = aNode._2 val data = node.data val value = s.a.valueMap(node.id) @@ -81,7 +81,7 @@ object ConstantCppWriter { override def defModuleAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Out = { val (_, node, _) = aNode val data = node.data val members = data.members.flatMap(matchModuleMember(s, _)) @@ -96,14 +96,14 @@ object ConstantCppWriter { override def defComponentAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): List[CppDoc.Member] = { val (_, node, _) = aNode val data = node.data val members = data.members.flatMap(matchComponentMember(s, _)) members } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = + override def transUnit(s: CppWriterState, tu: Ast.TransUnit): List[CppDoc.Member] = tu.members.flatMap(matchTuMember(s, _)) private def writeBooleanConstant(name: String, value: String) = diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDoc.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDoc.scala index c0f1a6cdf..40e2c68d9 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDoc.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDoc.scala @@ -104,7 +104,7 @@ object CppDoc { cppType: Option[String] = None ) { - def getCppType = cppType match { + def getCppType: String = cppType match { case Some(t) => t case None => hppType } diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala index db9920d35..89506738c 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala @@ -5,11 +5,11 @@ import java.time.Year /** Write a CppDoc to a cpp file */ object CppDocCppWriter extends CppDocWriter { - def paramString(p: CppDoc.Function.Param) = s"${p.t.hppType} ${p.name}" + def paramString(p: CppDoc.Function.Param): String = s"${p.t.hppType} ${p.name}" - def paramStringComma(p: CppDoc.Function.Param) = s"${paramString(p)}," + def paramStringComma(p: CppDoc.Function.Param): String = s"${paramString(p)}," - def writeParams(prefix: String, params: List[CppDoc.Function.Param]) = { + def writeParams(prefix: String, params: List[CppDoc.Function.Param]): List[Line] = { if (params.length == 0) lines(s"$prefix()") else if (params.length == 1) lines(s"$prefix(" ++ paramString(params.head) ++ ")") @@ -27,7 +27,7 @@ object CppDocCppWriter extends CppDocWriter { c.members.map(visitClassMember(in1, _)).flatten } - override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor) = { + override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor): List[Line] = { val unqualifiedClassName = in.getEnclosingClassUnqualified val qualifiedClassName = in.getEnclosingClassQualified val outputLines = { @@ -69,7 +69,7 @@ object CppDocCppWriter extends CppDocWriter { ).flatten } - override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor) = { + override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor): List[Line] = { val unqualifiedClassName = in.getEnclosingClassUnqualified val qualifiedClassName = in.getEnclosingClassQualified val outputLines = { @@ -81,7 +81,7 @@ object CppDocCppWriter extends CppDocWriter { outputLines } - override def visitFunction(in: Input, function: CppDoc.Function) = { + override def visitFunction(in: Input, function: CppDoc.Function): List[Line] = { val contentLines = { val startLines = { val prototypeLines = { @@ -111,7 +111,7 @@ object CppDocCppWriter extends CppDocWriter { Line.blank :: contentLines } - override def visitLines(in: Input, lines: CppDoc.Lines) = { + override def visitLines(in: Input, lines: CppDoc.Lines): Output = { val content = lines.content lines.output match { case CppDoc.Lines.Hpp => Nil diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala index 28213226f..8f4c07e03 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala @@ -5,12 +5,12 @@ import java.time.Year /** Write a CppDoc to an hpp file */ object CppDocHppWriter extends CppDocWriter { - def addParamComment(s: String, commentOpt: Option[String]) = commentOpt match { + def addParamComment(s: String, commentOpt: Option[String]): String = commentOpt match { case Some(comment) => s"$s //!< ${"\n".r.replaceAllIn(comment, " ")}" case None => s } - def closeIncludeGuard = lines( + def closeIncludeGuard: List[Line] = lines( """| |#endif""" ) @@ -23,24 +23,24 @@ object CppDocHppWriter extends CppDocWriter { ) } - def paramString(p: CppDoc.Function.Param) = { + def paramString(p: CppDoc.Function.Param): String = { val s1 = CppDocCppWriter.paramString(p) val s2 = addParamComment(s1, p.comment) s2 } - def paramStringComma(p: CppDoc.Function.Param) = { + def paramStringComma(p: CppDoc.Function.Param): String = { val s1 = CppDocCppWriter.paramStringComma(p) val s2 = addParamComment(s1, p.comment) s2 } - def writeAccessTag(tag: String) = List( + def writeAccessTag(tag: String): List[Line] = List( Line.blank, line(s"$tag:").indentOut(2) ) - def writeParams(prefix: String, params: List[CppDoc.Function.Param]) = { + def writeParams(prefix: String, params: List[CppDoc.Function.Param]): List[Line] = { if (params.length == 0) lines(s"$prefix()") else if (params.length == 1 && params.head.comment.isEmpty) lines(s"$prefix(" ++ CppDocCppWriter.paramString(params.head) ++ ")") @@ -72,7 +72,7 @@ object CppDocHppWriter extends CppDocWriter { commentLines ++ openLines ++ bodyLines ++ closeLines } - override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor) = { + override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor): List[Line] = { val unqualifiedClassName = in.getEnclosingClassUnqualified val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(constructor.comment) @@ -100,7 +100,7 @@ object CppDocHppWriter extends CppDocWriter { ).flatten } - override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor) = { + override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor): List[Line] = { val unqualifiedClassName = in.getEnclosingClassUnqualified val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(destructor.comment) @@ -113,7 +113,7 @@ object CppDocHppWriter extends CppDocWriter { outputLines } - override def visitFunction(in: Input, function: CppDoc.Function) = { + override def visitFunction(in: Input, function: CppDoc.Function): List[Line] = { import CppDoc.Function._ val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(function.comment) @@ -145,7 +145,7 @@ object CppDocHppWriter extends CppDocWriter { outputLines } - override def visitLines(in: Input, lines: CppDoc.Lines) = { + override def visitLines(in: Input, lines: CppDoc.Lines): Output = { val content = lines.content lines.output match { case CppDoc.Lines.Hpp => content diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocWriter.scala index fd9e81668..335b9b9b7 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocWriter.scala @@ -15,10 +15,10 @@ trait CppDocWriter extends CppDocVisitor with LineUtils { ) { /** Get the enclosing class name, including any qualifier */ - def getEnclosingClassQualified = classNameList.reverse.mkString("::") + def getEnclosingClassQualified: String = classNameList.reverse.mkString("::") /** Get the enclosing class name with no qualifier */ - def getEnclosingClassUnqualified = classNameList.head.split("::").reverse.head + def getEnclosingClassUnqualified: String = classNameList.head.split("::").reverse.head } @@ -34,10 +34,10 @@ trait CppDocWriter extends CppDocVisitor with LineUtils { def visitCppDoc(cppDoc: CppDoc): Output /** Write a parameter with no trailing comma as a line */ - final def writeParam(p: CppDoc.Function.Param) = line(paramString(p)) + final def writeParam(p: CppDoc.Function.Param): Line = line(paramString(p)) /** Write a parameter with a trailing comma as a line */ - final def writeParamComma(p: CppDoc.Function.Param) = line(paramStringComma(p)) + final def writeParamComma(p: CppDoc.Function.Param): Line = line(paramStringComma(p)) type Output = List[Line] @@ -46,34 +46,34 @@ trait CppDocWriter extends CppDocVisitor with LineUtils { object CppDocWriter extends LineUtils { /** Write a banner comment */ - def writeBannerComment(comment: String) = { + def writeBannerComment(comment: String): List[Line] = { def banner = line("// ----------------------------------------------------------------------") (Line.blank :: banner :: writeCommentBody(comment)) :+ banner } /** Write a comment */ - def writeComment(comment: String) = Line.blank :: writeCommentBody(comment) + def writeComment(comment: String): List[Line] = Line.blank :: writeCommentBody(comment) /** Write an optional Doxygen comment */ - def writeDoxygenCommentOpt(commentOpt: Option[String]) = commentOpt match { + def writeDoxygenCommentOpt(commentOpt: Option[String]): List[Line] = commentOpt match { case Some(comment) => writeDoxygenComment(comment) case None => Line.blank :: Nil } /** Write a Doxygen comment */ - def writeDoxygenComment(comment: String) = + def writeDoxygenComment(comment: String): List[Line] = Line.blank ::lines(comment).map(Line.join(" ")(line("//!"))_) /** Write a comment body */ - def writeCommentBody(comment: String) = lines(comment).map(Line.join(" ")(line("//"))_) + def writeCommentBody(comment: String): List[Line] = lines(comment).map(Line.join(" ")(line("//"))_) /** Left align a compiler directive */ - def leftAlignDirective(line: Line) = + def leftAlignDirective(line: Line): Line = if (line.string.startsWith("#")) Line(line.string) else line /** Write a header banner */ - def writeBanner(title: String, description: String) = lines( + def writeBanner(title: String, description: String): List[Line] = lines( s"""|// ====================================================================== |// \\title $title |// \\author Generated by fpp-to-cpp @@ -82,7 +82,7 @@ object CppDocWriter extends LineUtils { ) /** Write a function body */ - def writeFunctionBody(body: List[Line]) = { + def writeFunctionBody(body: List[Line]): List[Line] = { val bodyLines = body.length match { case 0 => Line.blank :: Nil case _ => body.map(indentIn(_)) diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala index 8a24ec068..cc7aed183 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala @@ -12,7 +12,7 @@ object CppWriter extends AstStateVisitor with LineUtils { override def defModuleAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Result = { val node = aNode._2 val data = node.data visitList(s, data.members, matchModuleMember) @@ -21,17 +21,17 @@ object CppWriter extends AstStateVisitor with LineUtils { override def defTopologyAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): Either[Error,CppWriterState] = { val node = aNode._2 val data = node.data val cppDoc = TopologyCppWriter(s, aNode).write writeCppDoc(s, cppDoc) } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = + override def transUnit(s: CppWriterState, tu: Ast.TransUnit): Result = visitList(s, tu.members, matchTuMember) - def tuList(s: CppWriterState, tul: List[Ast.TransUnit]) = + def tuList(s: CppWriterState, tul: List[Ast.TransUnit]): Either[Error,Unit] = for { _ <- ConstantCppWriter.write(s, tul) _ <- visitList(s, tul, transUnit) @@ -43,27 +43,27 @@ object CppWriter extends AstStateVisitor with LineUtils { fileName: String, includeGuard: String, members: List[CppDoc.Member] - ) = { + ): CppDoc = { val hppFile = CppDoc.HppFile(s"$fileName.hpp", includeGuard) CppDoc(description, hppFile, s"$fileName.cpp", members) } - def headerString(s: String) = { + def headerString(s: String): String = { val q = "\"" s"#include $q$s$q" } - def headerLine(s: String) = line(headerString(s)) + def headerLine(s: String): Line = line(headerString(s)) def linesMember( content: List[Line], output: CppDoc.Lines.Output = CppDoc.Lines.Hpp - ) = CppDoc.Member.Lines(CppDoc.Lines(content, output)) + ): CppDoc.Member.Lines = CppDoc.Member.Lines(CppDoc.Lines(content, output)) def namespaceMember( name: String, members: List[CppDoc.Member] - ) = CppDoc.Member.Namespace(CppDoc.Namespace(name, members)) + ): CppDoc.Member.Namespace = CppDoc.Member.Namespace(CppDoc.Namespace(name, members)) def wrapInNamespaces( namespaceNames: List[String], @@ -74,7 +74,7 @@ object CppWriter extends AstStateVisitor with LineUtils { List(namespaceMember(head, wrapInNamespaces(tail, members))) } - def writeCppDoc(s: CppWriterState, cppDoc: CppDoc) = + def writeCppDoc(s: CppWriterState, cppDoc: CppDoc): Either[Error,CppWriterState] = for { _ <- writeHppFile(s, cppDoc) _ <- writeCppFile(s, cppDoc) @@ -105,11 +105,11 @@ object CppWriter extends AstStateVisitor with LineUtils { } /** Constructs a C++ identifier from a qualified name */ - def identFromQualifiedName(name: Name.Qualified) = + def identFromQualifiedName(name: Name.Qualified): String = name.toString.replaceAll("\\.", "_") /** Translates a qualified name to C++ */ - def translateQualifiedName(name: Name.Qualified) = + def translateQualifiedName(name: Name.Qualified): String = name.toString.replaceAll("\\.", "::") /** Writes an identifier */ diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriterState.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriterState.scala index d6fadb39c..f9b94af09 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriterState.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriterState.scala @@ -42,7 +42,7 @@ case class CppWriterState( } /** Constructs an include guard from the prefix and a name */ - def includeGuardFromPrefix(name: String) = { + def includeGuardFromPrefix(name: String): String = { val rawPrefix = guardPrefix.getOrElse(getRelativePath(".").toString) val prefix = "[^A-Za-z0-9_]".r.replaceAllIn(rawPrefix, "_") prefix match { @@ -52,11 +52,11 @@ case class CppWriterState( } /** Constructs a C++ identifier from a qualified symbol name */ - def identFromQualifiedSymbolName(s: Symbol) = + def identFromQualifiedSymbolName(s: Symbol): String = CppWriter.identFromQualifiedName(a.getQualifiedName(s)) /** Constructs an include guard from a qualified name and a kind */ - def includeGuardFromQualifiedName(s: Symbol, name: String) = { + def includeGuardFromQualifiedName(s: Symbol, name: String): String = { val guard = a.getEnclosingNames(s) match { case Nil => name case names => diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/TopologyCppWriter/TopologyCppWriterUtils.scala b/compiler/lib/src/main/scala/codegen/CppWriter/TopologyCppWriter/TopologyCppWriterUtils.scala index 18c2acd84..94f370836 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/TopologyCppWriter/TopologyCppWriterUtils.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/TopologyCppWriter/TopologyCppWriterUtils.scala @@ -10,28 +10,28 @@ abstract class TopologyCppWriterUtils( aNode: Ast.Annotated[AstNode[Ast.DefTopology]] ) extends LineUtils { - val symbol = Symbol.Topology(aNode) + val symbol: Symbol.Topology = Symbol.Topology(aNode) - val namespaceIdentList = s.getNamespaceIdentList(symbol) + val namespaceIdentList: List[String] = s.getNamespaceIdentList(symbol) val name = aNode._2.data.name - val t = s.a.topologyMap(symbol) + val t: Topology = s.a.topologyMap(symbol) val instances = t.instanceMap.keys.toList.sorted - val instancesByBaseId = instances.sortWith { + val instancesByBaseId: List[ComponentInstance] = instances.sortWith { case (a, b) => if (a.baseId != b.baseId) a.baseId < b.baseId else a < b } - def isActive(ci: ComponentInstance) = + def isActive(ci: ComponentInstance): Boolean = ci.component.aNode._2.data.kind == Ast.ComponentKind.Active - def hasCommands(ci: ComponentInstance) = + def hasCommands(ci: ComponentInstance): Boolean = ci.component.commandMap.size > 0 - def hasParams(ci: ComponentInstance) = + def hasParams(ci: ComponentInstance): Boolean = ci.component.paramMap.size > 0 def addBannerComment(comment: String, ll: List[Line]): List[Line] = @@ -52,15 +52,15 @@ abstract class TopologyCppWriterUtils( def getComponentNameAsQualIdent(ci: ComponentInstance): String = getNameAsQualIdent(getComponentName(ci)) - def getShortName(name: Name.Qualified) = { + def getShortName(name: Name.Qualified): Name.Qualified = { val ens = s.a.getEnclosingNames(symbol) name.shortName(ens) } - def getNameAsIdent(name: Name.Qualified) = + def getNameAsIdent(name: Name.Qualified): String = CppWriter.identFromQualifiedName(getShortName(name)) - def getNameAsQualIdent(name: Name.Qualified) = + def getNameAsQualIdent(name: Name.Qualified): String = CppWriter.translateQualifiedName(getShortName(name)) def wrapInScope( diff --git a/compiler/lib/src/main/scala/codegen/FppWriter.scala b/compiler/lib/src/main/scala/codegen/FppWriter.scala index 72e08ba11..7b58b20e6 100644 --- a/compiler/lib/src/main/scala/codegen/FppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/FppWriter.scala @@ -9,27 +9,27 @@ object FppWriter extends AstVisitor with LineUtils { private case class JoinOps(ls: List[Line]) { - def addSuffix(suffix: String) = Line.addSuffix(ls, suffix) + def addSuffix(suffix: String): List[Line] = Line.addSuffix(ls, suffix) - def join (sep: String) (ls1: List[Line]) = + def join (sep: String) (ls1: List[Line]): List[Line] = Line.joinLists (Line.Indent) (ls) (sep) (ls1) - def joinNoIndent (sep: String) (ls1: List[Line]) = + def joinNoIndent (sep: String) (ls1: List[Line]): List[Line] = Line.joinLists (Line.NoIndent) (ls) (sep) (ls1) - def joinWithBreak[T] (sep: String) (ls1: List[Line]) = + def joinWithBreak[T] (sep: String) (ls1: List[Line]): List[Line] = (sep, ls1) match { case ("", Nil) => ls case _ => Line.addSuffix(ls, " \\") ++ Line.addPrefix(sep, ls1).map(indentIn) } - def joinOpt[T] (opt: Option[T]) (sep: String) (f: T => List[Line]) = + def joinOpt[T] (opt: Option[T]) (sep: String) (f: T => List[Line]): List[Line] = opt match { case Some(t) => join (sep) (f(t)) case None => ls } - def joinOptWithBreak[T] (opt: Option[T]) (sep: String) (f: T => List[Line]) = + def joinOptWithBreak[T] (opt: Option[T]) (sep: String) (f: T => List[Line]): List[Line] = opt match { case Some(t) => joinWithBreak (sep) (f(t)) case None => ls @@ -37,21 +37,21 @@ object FppWriter extends AstVisitor with LineUtils { } - private implicit def lift(ls: List[Line]) = JoinOps(ls) + private implicit def lift(ls: List[Line]): JoinOps = JoinOps(ls) - def componentMember(member: Ast.ComponentMember) = { + def componentMember(member: Ast.ComponentMember): List[Line] = { val (a1, _, a2) = member.node val l = matchComponentMember((), member) annotate(a1, l, a2) } - def moduleMember(member: Ast.ModuleMember) = { + def moduleMember(member: Ast.ModuleMember): List[Line] = { val (a1, _, a2) = member.node val l = matchModuleMember((), member) annotate(a1, l, a2) } - def topologyMember(member: Ast.TopologyMember) = { + def topologyMember(member: Ast.TopologyMember): List[Line] = { val (a1, _, a2) = member.node val l = matchTopologyMember((), member) annotate(a1, l, a2) @@ -59,15 +59,15 @@ object FppWriter extends AstVisitor with LineUtils { def transUnit(tu: Ast.TransUnit): Out = transUnit((), tu) - def tuMember(tum: Ast.TUMember) = moduleMember(tum) + def tuMember(tum: Ast.TUMember): List[Line] = moduleMember(tum) - def tuMemberList(tuml: List[Ast.TUMember]) = + def tuMemberList(tuml: List[Ast.TUMember]): List[Line] = Line.blankSeparated (tuMember) (tuml) override def defAbsTypeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"type ${ident(data.name)}") @@ -76,7 +76,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defArrayAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"array ${ident(data.name)} = ["). @@ -89,7 +89,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defComponentAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -101,7 +101,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defComponentInstanceAnnotatedNode( in: In, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ) = { + ): List[Line] = { def initSpecs(list: List[Ast.Annotated[AstNode[Ast.SpecInit]]]) = addBracesIfNonempty(list.flatMap(annotateNode(specInit))) val (_, node, _) = aNode @@ -120,7 +120,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defConstantAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"constant ${ident(data.name)}").join (" = ") (exprNode(data.value)) @@ -129,7 +129,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defEnumAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"enum ${ident(data.name)}"). @@ -142,7 +142,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defModuleAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data List(line(s"module ${ident(data.name)} {"), Line.blank) ++ @@ -153,7 +153,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"port ${ident(data.name)}"). @@ -164,7 +164,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defStructAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"struct ${ident(data.name)}"). @@ -177,7 +177,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( in: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data List(line(s"topology ${ident(data.name)} {"), Line.blank) ++ @@ -185,80 +185,80 @@ object FppWriter extends AstVisitor with LineUtils { List(Line.blank, line("}")) } - override def default(in: Unit) = + override def default(in: Unit): Out = throw new InternalError("FppWriter: Visitor not implemented") override def exprArrayNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprArray - ) = + ): List[Line] = (line("[") :: e.elts.flatMap(exprNode).map(indentIn)) :+ line("]") override def exprBinopNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprBinop - ) = exprNode(e.e1).join (binop(e.op)) (exprNode(e.e2)) + ): List[Line] = exprNode(e.e1).join (binop(e.op)) (exprNode(e.e2)) override def exprDotNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprDot - ) = exprNode(e.e).join (".") (lines(e.id.data)) + ): List[Line] = exprNode(e.e).join (".") (lines(e.id.data)) override def exprIdentNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprIdent - ) = lines(e.value) + ): List[Line] = lines(e.value) override def exprLiteralBoolNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool - ) = lines(e.value.toString) + ): List[Line] = lines(e.value.toString) override def exprLiteralFloatNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat - ) = lines(e.value) + ): List[Line] = lines(e.value) override def exprLiteralIntNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt - ) = lines(e.value) + ): List[Line] = lines(e.value) override def exprLiteralStringNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString - ) = string(e.value) + ): List[Line] = string(e.value) override def exprParenNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprParen - ) = Line.addPrefixAndSuffix("(", exprNode(e.e), ")") + ): List[Line] = Line.addPrefixAndSuffix("(", exprNode(e.e), ")") override def exprStructNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprStruct - ) = addBraces(e.members.flatMap(applyToData(structMember))) + ): List[Line] = addBraces(e.members.flatMap(applyToData(structMember))) override def exprUnopNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprUnop - ) = lines(unop(e.op)).join ("") (exprNode(e.e)) + ): List[Line] = lines(unop(e.op)).join ("") (exprNode(e.e)) override def specCommandAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -272,7 +272,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specCompInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val visibility = data.visibility match { @@ -286,7 +286,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specConnectionGraphAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ) = { + ): Out = { val (_, node, _) = aNode def direct(scg: Ast.SpecConnectionGraph.Direct) = lines(s"connections ${ident(scg.name)}"). @@ -311,7 +311,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specEventAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val severity = data.severity.toString @@ -326,7 +326,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specIncludeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInclude]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines("include").join (" ") (string(data.file.data)) @@ -335,7 +335,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specInternalPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"internal port ${ident(data.name)}"). @@ -347,7 +347,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specLocAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecLoc]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -359,7 +359,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specParamAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data lines(s"param ${ident(data.name)}"). @@ -373,7 +373,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specPortInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ) = { + ): Out = { val (_, node, _) = aNode def general(i: Ast.SpecPortInstance.General) = { val kind = i.kind.toString @@ -401,7 +401,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specPortMatchingAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val port1 = data.port1.data @@ -412,7 +412,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specTlmChannelAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data def update(u: Ast.SpecTlmChannel.Update) = lines(u.toString) @@ -438,7 +438,7 @@ object FppWriter extends AstVisitor with LineUtils { override def specTopImportAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data Line.addPrefix("import ", qualIdent(data.top.data)) @@ -447,36 +447,36 @@ object FppWriter extends AstVisitor with LineUtils { override def transUnit( in: Unit, tu: Ast.TransUnit - ) = tuMemberList(tu.members) + ): List[Line] = tuMemberList(tu.members) override def typeNameBoolNode( in: Unit, node: AstNode[Ast.TypeName] - ) = lines("bool") + ): List[Line] = lines("bool") override def typeNameFloatNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat - ) = lines(tn.name.toString) + ): List[Line] = lines(tn.name.toString) override def typeNameIntNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt - ) = lines(tn.name.toString) + ): List[Line] = lines(tn.name.toString) override def typeNameQualIdentNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent - ) = qualIdent(tn.name.data) + ): List[Line] = qualIdent(tn.name.data) override def typeNameStringNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ) = lines("string").joinOpt (tn.size) (" size ") (exprNode) + ): List[Line] = lines("string").joinOpt (tn.size) (" size ") (exprNode) private def addBraces(ls: List[Line]): List[Line] = line("{") :: (ls.map(indentIn) :+ line("}")) @@ -590,7 +590,7 @@ object FppWriter extends AstVisitor with LineUtils { type Out = List[Line] - val keywords = Set( + val keywords: Set[String] = Set( "F32", "F64", "I16", diff --git a/compiler/lib/src/main/scala/codegen/Indentation.scala b/compiler/lib/src/main/scala/codegen/Indentation.scala index fa7f95b50..851c87571 100644 --- a/compiler/lib/src/main/scala/codegen/Indentation.scala +++ b/compiler/lib/src/main/scala/codegen/Indentation.scala @@ -6,7 +6,7 @@ package fpp.compiler.codegen case class Indentation(n: Int) { /** Format the indentation as a string of spaces */ - override def toString = { + override def toString: String = { def helper(n: Int, s: String): String = if (n < 1) s else helper(n - 1, " " ++ s) helper(n, "") @@ -16,9 +16,9 @@ case class Indentation(n: Int) { def toInt: Int = n /** Indent in by the given space count */ - def indentIn(incr: Int) = Indentation(n + incr) + def indentIn(incr: Int): Indentation = Indentation(n + incr) /** Indent out by the given space count */ - def indentOut(incr: Int) = Indentation(n - incr) + def indentOut(incr: Int): Indentation = Indentation(n - incr) } diff --git a/compiler/lib/src/main/scala/codegen/Line.scala b/compiler/lib/src/main/scala/codegen/Line.scala index e1d3f1a76..a2df19623 100644 --- a/compiler/lib/src/main/scala/codegen/Line.scala +++ b/compiler/lib/src/main/scala/codegen/Line.scala @@ -9,21 +9,21 @@ object Line { val stdout = new java.io.PrintWriter(System.out, true) - def addPrefix(prefix: String, ls: List[Line]) = + def addPrefix(prefix: String, ls: List[Line]): List[Line] = joinLists(Line.NoIndent)(List(Line(prefix)))("")(ls) - def addPrefixAndSuffix(prefix: String, ls: List[Line], suffix: String) = + def addPrefixAndSuffix(prefix: String, ls: List[Line], suffix: String): List[Line] = addPrefix(prefix, addSuffix(ls, suffix)) - def addPrefixIndent(prefix: String, ls: List[Line]) = + def addPrefixIndent(prefix: String, ls: List[Line]): List[Line] = joinLists(Line.Indent)(List(Line(prefix)))("")(ls) - def addSuffix(ls: List[Line], suffix: String) = + def addSuffix(ls: List[Line], suffix: String): List[Line] = joinLists(Line.NoIndent)(ls)("")(List(Line(suffix))) def blank: Line = Line() - def write (writer: java.io.PrintWriter) (line: Line) = { + def write (writer: java.io.PrintWriter) (line: Line): Unit = { writer.println(line.toString) } @@ -99,19 +99,19 @@ object Line { case class Line(string: String = "", indent: Indentation = Indentation(0)) { /** Convert the line to a formatted string */ - override def toString = string match { + override def toString: String = string match { case "" => "" case _ => indent.toString ++ string } /** Indent in */ - def indentIn(n: Int) = this.copy(indent = indent.indentIn(n)) + def indentIn(n: Int): Line = this.copy(indent = indent.indentIn(n)) /** Indent out */ - def indentOut(n: Int) = this.copy(indent = indent.indentOut(n)) + def indentOut(n: Int): Line = this.copy(indent = indent.indentOut(n)) /** Absolute indent */ - def indent(n: Int) = this.copy(indent = Indentation(n)) + def indent(n: Int): Line = this.copy(indent = Indentation(n)) /** Get the size of a line. * Includes the indentation, but not the newline */ diff --git a/compiler/lib/src/main/scala/codegen/LineUtils.scala b/compiler/lib/src/main/scala/codegen/LineUtils.scala index 824125678..bbcd866a8 100644 --- a/compiler/lib/src/main/scala/codegen/LineUtils.scala +++ b/compiler/lib/src/main/scala/codegen/LineUtils.scala @@ -3,13 +3,13 @@ package fpp.compiler.codegen /** Utilities for writing lines */ trait LineUtils { - def indentIn(line: Line) = line.indentIn(indentIncrement) + def indentIn(line: Line): Line = line.indentIn(indentIncrement) - def line(s: String) = Line(s) + def line(s: String): Line = Line(s) - def lines(s: String) = s.stripMargin.split("\n").map(line(_)).toList + def lines(s: String): List[Line] = s.stripMargin.split("\n").map(line(_)).toList - def linesOpt[T](f: T => List[Line], o: Option[T]) = + def linesOpt[T](f: T => List[Line], o: Option[T]): List[Line] = o match { case Some(x) => f(x) case None => Nil @@ -19,10 +19,10 @@ trait LineUtils { val indentIncrement = 2 - val addBlankPrefix = Line.addPrefixLine (Line.blank) _ + val addBlankPrefix: List[Line] => List[Line] = Line.addPrefixLine (Line.blank) _ - val addBlankPostfix = Line.addPostfixLine (Line.blank) _ + val addBlankPostfix: List[Line] => List[Line] = Line.addPostfixLine (Line.blank) _ - val flattenWithBlankPrefix = Line.flattenWithPrefixLine (Line.blank) _ + val flattenWithBlankPrefix: List[List[Line]] => List[Line] = Line.flattenWithPrefixLine (Line.blank) _ } diff --git a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala index 39bf4d514..80a45cf98 100644 --- a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala @@ -20,7 +20,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defAbsTypeAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) @@ -29,7 +29,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defArrayAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) @@ -38,7 +38,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defComponentAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data val s1 = s.copy(scopeNameList = data.name :: s.scopeNameList) @@ -49,7 +49,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defComponentInstanceAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.ComponentInstance, data.name, node) @@ -58,7 +58,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defConstantAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Constant, data.name, node) @@ -67,7 +67,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defEnumAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) @@ -76,7 +76,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defModuleAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val Ast.DefModule(name, members) = node.data val s1 = s.copy(scopeNameList = name :: s.scopeNameList) @@ -86,7 +86,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defPortAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Port, data.name, node) @@ -95,7 +95,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defStructAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) @@ -104,13 +104,13 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): List[Line] = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Topology, data.name, node) } - override def transUnit(s: State, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit): List[Line] = tu.members.flatMap(matchModuleMember(s, _)) private def writeSpecLoc[T]( diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala index f3f23e4fc..5d136a25c 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala @@ -4,6 +4,7 @@ import fpp.compiler.ast._ import fpp.compiler.analysis import fpp.compiler.codegen._ import fpp.compiler.util._ +import scala.xml.Node /** Writes out an F Prime XML array as FPP source */ object ArrayXmlFppWriter extends LineUtils { @@ -15,7 +16,7 @@ object ArrayXmlFppWriter extends LineUtils { private object FppBuilder { /** Translates an XML type to an FPP type name */ - def translateType(file: XmlFppWriter.File) = file.translateType(node => Right(node.text)) _ + def translateType(file: XmlFppWriter.File): Node => Result.Result[Ast.TypeName] = file.translateType(node => Right(node.text)) _ /** Translates a block of default values from FPP to XML */ def translateDefaults(node: scala.xml.Node, tn: Ast.TypeName): (Option[AstNode[Ast.Expr]], List[String]) = { diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala index 90ea279fe..303d0e2a7 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala @@ -3,6 +3,7 @@ package fpp.compiler.codegen import fpp.compiler.ast._ import fpp.compiler.codegen._ import fpp.compiler.util._ +import scala.xml.Node /** Writes out an F Prime XML component as FPP source */ object ComponentXmlFppWriter extends LineUtils { @@ -20,22 +21,22 @@ object ComponentXmlFppWriter extends LineUtils { yield Line.blankSeparated (FppWriter.componentMember) (members) /** Writes a commands file */ - val writeCommandsFile = writeImportedFile(FppBuilder.MemberGenerator.Command) _ + val writeCommandsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.Command) _ /** Writes a params file */ - val writeParamsFile = writeImportedFile(FppBuilder.MemberGenerator.Param) _ + val writeParamsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.Param) _ /** Writes a ports file */ - val writePortsFile = writeImportedFile(FppBuilder.MemberGenerator.Port) _ + val writePortsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.Port) _ /** Writes a tlm channels file */ - val writeTlmChannelsFile = writeImportedFile(FppBuilder.MemberGenerator.TlmChannel) _ + val writeTlmChannelsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.TlmChannel) _ /** Writes an events file */ - val writeEventsFile = writeImportedFile(FppBuilder.MemberGenerator.Event) _ + val writeEventsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.Event) _ /** Writes an internal ports file */ - val writeInternalPortsFile = writeImportedFile(FppBuilder.MemberGenerator.InternalPort) _ + val writeInternalPortsFile: XmlFppWriter.File => XmlFppWriter.Result = writeImportedFile(FppBuilder.MemberGenerator.InternalPort) _ /** Builds FPP for translating Component XML */ private object FppBuilder { @@ -69,7 +70,7 @@ object ComponentXmlFppWriter extends LineUtils { yield List(node) /** Generates a list of members */ - final def generateMembers(file: XmlFppWriter.File, node: scala.xml.Node) = + final def generateMembers(file: XmlFppWriter.File, node: scala.xml.Node): Either[Error,List[Ast.ComponentMember]] = generateMemberNodes(file, node) match { case Left(error) => Left(error) case Right(aNodes) => Right(aNodes.map(Ast.ComponentMember(_))) @@ -91,7 +92,7 @@ object ComponentXmlFppWriter extends LineUtils { yield enums.map(constructEnumMember) /** Translates an optional integer attribute */ - def translateIntegerOpt(xmlNode: scala.xml.Node, name: String) = + def translateIntegerOpt(xmlNode: scala.xml.Node, name: String): Option[AstNode[Ast.ExprLiteralInt]] = XmlFppWriter.getAttributeOpt(xmlNode, name).map( text => AstNode.create(Ast.ExprLiteralInt(text)) ) @@ -117,7 +118,7 @@ object ComponentXmlFppWriter extends LineUtils { yield qfo.map(AstNode.create(_)) /** Translates an XML type to an FPP type name */ - def translateType(file: XmlFppWriter.File) = + def translateType(file: XmlFppWriter.File): Node => Result.Result[Ast.TypeName] = file.translateType(node => file.getAttribute(node, "data_type")) _ case object MemberGenerator { @@ -126,7 +127,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "import_dictionary" - override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = + override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,(List[String], Ast.ComponentMember.SpecInclude, Nil.type)] = for { child <- file.getUniqueChild(xmlNode) } @@ -150,7 +151,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "port" - def general(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { + def general(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,Ast.SpecPortInstance.General] = { import Ast.SpecPortInstance._ for { xmlKind <- file.getAttribute(xmlNode, "kind") @@ -178,7 +179,7 @@ object ComponentXmlFppWriter extends LineUtils { } } - def special(file: XmlFppWriter.File, xmlNode: scala.xml.Node, role: String) = { + def special(file: XmlFppWriter.File, xmlNode: scala.xml.Node, role: String): Either[Error,Ast.SpecPortInstance.Special] = { import Ast.SpecPortInstance._ for { kind <- role match { @@ -198,7 +199,7 @@ object ComponentXmlFppWriter extends LineUtils { yield Special(kind, name) } - override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { + override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,(List[String], Ast.ComponentMember.SpecPortInstance, Nil.type)] = { for { comment <- file.getComment(xmlNode) member <- XmlFppWriter.getAttributeOpt(xmlNode, "role") match { @@ -219,7 +220,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "internal_interface" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = for { annotatedEnumMemberNodes <- translateArgEnums(file, xmlNode) comment <- file.getComment(xmlNode) @@ -244,7 +245,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "command" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = for { xmlKind <- file.getAttribute(xmlNode, "kind") kind <- xmlKind match { @@ -284,7 +285,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "event" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = for { annotatedEnumMemberNodes <- translateArgEnums(file, xmlNode) comment <- file.getComment(xmlNode) @@ -334,7 +335,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "parameter" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[Ast.Annotated[Ast.ComponentMember.Node]]] = { for { enumAnnotatedOpt <- XmlFppWriter.FppBuilder.InlineEnumBuilder.defEnumAnnotatedOpt(file)(xmlNode) comment <- file.getComment(xmlNode) @@ -383,7 +384,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "channel" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[Ast.Annotated[Ast.ComponentMember.Node]]] = { type Limits = List[Ast.SpecTlmChannel.Limit] def translateLimits( direction: String, @@ -462,7 +463,7 @@ object ComponentXmlFppWriter extends LineUtils { type MemListListRes = Result.Result[List[List[Ast.ComponentMember]]] /** Maps a node generator onto children at the top level */ - def mapChildren(file: XmlFppWriter.File, memberGenerator: MemberGenerator) = + def mapChildren(file: XmlFppWriter.File, memberGenerator: MemberGenerator): MemListRes = mapChildrenOfNodeOpt(file, Some(file.elem), memberGenerator) /** Maps a node generator onto the children of an XML node */ diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/FormalParamsXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/FormalParamsXmlFppWriter.scala index bb2bd3174..ed37c22c7 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/FormalParamsXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/FormalParamsXmlFppWriter.scala @@ -3,12 +3,13 @@ package fpp.compiler.codegen import fpp.compiler.ast._ import fpp.compiler.codegen._ import fpp.compiler.util._ +import scala.xml.Node /** Writes out F Prime XML arguments as FPP formal parameters */ object FormalParamsXmlFppWriter extends LineUtils { /** Translates an XML type to an FPP type name */ - def translateType(file: XmlFppWriter.File) = + def translateType(file: XmlFppWriter.File): Node => Result.Result[Ast.TypeName] = file.translateType(node => file.getAttribute(node, "type")) _ /** Extracts a formal parameter */ diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala index eea8078b2..5c9aa2665 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala @@ -3,6 +3,7 @@ package fpp.compiler.codegen import fpp.compiler.ast._ import fpp.compiler.codegen._ import fpp.compiler.util._ +import scala.xml.Node /** Writes out an F Prime XML port as FPP source */ object PortXmlFppWriter extends LineUtils { @@ -15,7 +16,7 @@ object PortXmlFppWriter extends LineUtils { private object FppBuilder { /** Translates an XML type to an FPP type name */ - def translateType(file: XmlFppWriter.File) = + def translateType(file: XmlFppWriter.File): Node => Result.Result[Ast.TypeName] = file.translateType(node => file.getAttribute(node, "type")) _ /** Extracts the return type */ diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala index 3166eab30..0b6c881ba 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala @@ -3,6 +3,7 @@ package fpp.compiler.codegen import fpp.compiler.ast._ import fpp.compiler.codegen._ import fpp.compiler.util._ +import scala.xml.Node /** Writes out an F Prime XML Serializable struct as FPP source */ object StructXmlFppWriter extends LineUtils { @@ -15,7 +16,7 @@ object StructXmlFppWriter extends LineUtils { private object FppBuilder { /** Translates an XML type to an FPP type name */ - def translateType(file: XmlFppWriter.File) = + def translateType(file: XmlFppWriter.File): Node => Result.Result[Ast.TypeName] = file.translateType(node => file.getAttribute(node, "type")) _ /** Extracts a struct type member */ diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala index 6b692584f..6606a232c 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala @@ -18,10 +18,10 @@ object XmlFppWriter extends LineUtils { ) { /** Constructs an error containing the file name */ - def error(e: (String) => Error) = e(name) + def error(e: (String) => Error): Error = e(name) /** Constructs a semantic error with the given message */ - def semanticError(message: String) = error(XmlError.SemanticError(_, message)) + def semanticError(message: String): Error = error(XmlError.SemanticError(_, message)) /** Gets an attribute from a node, returning an error if it is not there */ def getAttribute(node: scala.xml.Node, name: String): Result.Result[String] = @@ -154,7 +154,7 @@ object XmlFppWriter extends LineUtils { } /** Constructs a translator note */ - def constructNote(s: String) = "FPP from XML: " ++ s + def constructNote(s: String): String = "FPP from XML: " ++ s /** Gets an attribute comment */ def getAttributeComment(node: scala.xml.Node): List[String] = @@ -175,7 +175,7 @@ object XmlFppWriter extends LineUtils { node.attribute(name).map(_.toList.head.toString) /** Writes a file list */ - def writeFileList(fileList: List[File]) = { + def writeFileList(fileList: List[File]): Either[Error,List[Line]] = { for (files <- Result.map(fileList, (file: File) => file.write)) yield Line.blankSeparated (identity[List[Line]]) (files) } @@ -186,7 +186,7 @@ object XmlFppWriter extends LineUtils { tumConstructor: AstNode[T] => Ast.TUMember.Node, moduleConstructor: AstNode[T] => Ast.ModuleMember.Node, file: XmlFppWriter.File - ) = tuMemberList( + ): Ast.TUMember = tuMemberList( Nil: List[Ast.Annotated[Ast.DefEnum]], Ast.TUMember.DefEnum, Ast.ModuleMember.DefEnum, @@ -197,7 +197,7 @@ object XmlFppWriter extends LineUtils { ).head /** Transforms an annotated AST node */ - def transformNode[A,B](transform: AstNode[A] => B)(a: Ast.Annotated[A]) = + def transformNode[A,B](transform: AstNode[A] => B)(a: Ast.Annotated[A]): (List[String], B, List[String]) = (a._1, transform(AstNode.create(a._2)), a._3) /** Builds a list of TU members from a list of annotated A elements @@ -261,11 +261,11 @@ object XmlFppWriter extends LineUtils { } /** Translates a qualified identifier type */ - def translateQualIdentType(xmlType: String) = + def translateQualIdentType(xmlType: String): Ast.TypeNameQualIdent = Ast.TypeNameQualIdent(translateQualIdent(xmlType)) /** Translates a qualified identifier */ - def translateQualIdent(xmlQid: String) = + def translateQualIdent(xmlQid: String): AstNode[Ast.QualIdent] = AstNode.create( Ast.QualIdent.fromNodeList( xmlQid.split("::").toList.map(AstNode.create(_)) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala index 1c33481ea..50ea8486e 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala @@ -9,7 +9,7 @@ object ArrayXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): List[Line] = { val node = aNode._2 val data = node.data val tags = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala index 445bf33e4..091e74e0a 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala @@ -10,7 +10,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { override def defComponentAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): List[Line] = { val symbol = Symbol.Component(aNode) val c = s.a.componentMap(symbol) val pairs = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala index 38f3763e7..77ebadb19 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala @@ -16,7 +16,7 @@ object ComputeXmlFiles extends AstStateVisitor { type State = XmlWriterState - override def defArrayAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefArray]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -25,7 +25,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defComponentAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefComponent]]) = { + override def defComponentAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,XmlWriterState] = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -38,7 +38,7 @@ object ComputeXmlFiles extends AstStateVisitor { yield s } - override def defEnumAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -50,13 +50,13 @@ object ComputeXmlFiles extends AstStateVisitor { override def defModuleAnnotatedNode( s: State, node: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Result = { val (_, node1, _) = node val data = node1.data visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefPort]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -65,7 +65,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defStructAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -74,7 +74,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defTopologyAnnotatedNode(s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { + override def defTopologyAnnotatedNode(s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { val (_, node, _) = aNode val data = node.data val loc = Locations.get(node.id) @@ -83,7 +83,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def transUnit(s: State, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit): Result = visitList(s, tu.members, matchTuMember) private def addMapping(s: State, fileName: String, loc: Location) = diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala index 113a4e95a..1500feeb0 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala @@ -9,7 +9,7 @@ object EnumXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): List[Line] = { val node = aNode._2 val data = node.data val enumType @ Type.Enum(_, _, _) = s.a.typeMap(node.id) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/FormalParamsXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/FormalParamsXmlWriter.scala index 60e2520e6..4b19c3fa7 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/FormalParamsXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/FormalParamsXmlWriter.scala @@ -10,7 +10,7 @@ object FormalParamsXmlWriter extends LineUtils { def formalParamList( s: XmlWriterState, params: Ast.FormalParamList - ) = params match { + ): List[Line] = params match { case Nil => Nil case _ => val ls = params.flatMap(formalParamAnnotatedNode(s, _)) @@ -21,7 +21,7 @@ object FormalParamsXmlWriter extends LineUtils { def formalParamAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.FormalParam]] - ) = { + ): List[Line] = { val node = aNode._2 val data = node.data val pairs = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala index afda38a77..2f30a6d3c 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala @@ -12,7 +12,7 @@ object PortXmlWriter extends AstVisitor with LineUtils { override def defPortAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ) = { + ): List[Line] = { val node = aNode._2 val data = node.data val tags = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala index a136b0023..2b3a97898 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala @@ -9,7 +9,7 @@ object StructXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): List[Line] = { val node = aNode._2 val data = node.data val tags = { @@ -35,7 +35,7 @@ object StructXmlWriter extends AstVisitor with LineUtils { s: XmlWriterState, structType: Type.Struct, aNode: Ast.Annotated[AstNode[Ast.StructTypeMember]] - ) = { + ): List[Line] = { val node = aNode._2 val data = node.data val t = s.a.typeMap(data.typeName.id) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala index 73d87cc0f..2b9f26a23 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala @@ -10,7 +10,7 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ) = { + ): List[Line] = { val symbol = Symbol.Topology(aNode) val t = s.a.topologyMap(symbol) val data = aNode._2.data diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala index 77b706f0d..3aebb7e82 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala @@ -8,17 +8,17 @@ object TypeXmlWriter { private object NameVisitor extends TypeVisitor { - override def absType(s: XmlWriterState, t: Type.AbsType) = + override def absType(s: XmlWriterState, t: Type.AbsType): String = s.writeSymbol(Symbol.AbsType(t.node)) - override def array(s: XmlWriterState, t: Type.Array) = + override def array(s: XmlWriterState, t: Type.Array): String = s.writeSymbol(Symbol.Array(t.node)) override def boolean(s: XmlWriterState) = "bool" - override def default(s: XmlWriterState, t: Type) = throw new InternalError("visitor not defined") + override def default(s: XmlWriterState, t: Type): Out = throw new InternalError("visitor not defined") - override def enumeration(s: XmlWriterState, t: Type.Enum) = + override def enumeration(s: XmlWriterState, t: Type.Enum): String = s.writeSymbol(Symbol.Enum(t.node)) override def float(s: XmlWriterState, t: Type.Float) = t.toString @@ -27,7 +27,7 @@ object TypeXmlWriter { override def string(s: XmlWriterState, t: Type.String) = "string" - override def struct(s: XmlWriterState, t: Type.Struct) = + override def struct(s: XmlWriterState, t: Type.Struct): String = s.writeSymbol(Symbol.Struct(t.node)) type In = XmlWriterState diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala index 148ebc21f..87bed7af0 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala @@ -30,7 +30,7 @@ object ValueXmlWriter { override def boolean(s: XmlWriterState, v: Value.Boolean) = v.value.toString - override def default(s: XmlWriterState, v: Value) = + override def default(s: XmlWriterState, v: Value): Out = throw new InternalError("visitor not defined") override def enumConstant(s: XmlWriterState, v: Value.EnumConstant): String = @@ -48,7 +48,7 @@ object ValueXmlWriter { override def primitiveInt(s: XmlWriterState, v: Value.PrimitiveInt) = v.value.toString - override def string(s: XmlWriterState, v: Value.String) = + override def string(s: XmlWriterState, v: Value.String): String = "\"" ++ v.value.toString.replaceAll("\\\\", "\\\\\\\\"). replaceAll("\"", "\\\\\"").replaceAll("\n", "\\\\n") ++ diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlTags.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlTags.scala index 2a347a05a..765baa905 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlTags.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlTags.scala @@ -3,13 +3,13 @@ package fpp.compiler.codegen /** Utilities for constructing XML Tags */ object XmlTags extends LineUtils { - def closeTag(name: String) = s"" + def closeTag(name: String): String = s"" - def openCloseTag(name: String, pairs: List[(String, String)] = Nil) = openTagPrefix(name, pairs) ++ "/>" + def openCloseTag(name: String, pairs: List[(String, String)] = Nil): String = openTagPrefix(name, pairs) ++ "/>" - def openTag(name: String, pairs: List[(String, String)] = Nil) = openTagPrefix(name, pairs) ++ ">" + def openTag(name: String, pairs: List[(String, String)] = Nil): String = openTagPrefix(name, pairs) ++ ">" - def quoted(s: String) = "\"" ++ s ++ "\"" + def quoted(s: String): String = "\"" ++ s ++ "\"" def taggedLines (tags: (String, String)) (ls: List[Line]): List[Line] = { val (openTag, closeTag) = tags @@ -28,12 +28,12 @@ object XmlTags extends LineUtils { case ls1 => taggedLines (name, pairs) (ls1) } - def taggedString (tags: (String, String)) (s: String) = { + def taggedString (tags: (String, String)) (s: String): String = { val (openTag, closeTag) = tags openTag ++ s ++ closeTag } - def tags(name: String, pairs: List[(String, String)] = Nil) = (openTag(name, pairs), closeTag(name)) + def tags(name: String, pairs: List[(String, String)] = Nil): (String, String) = (openTag(name, pairs), closeTag(name)) private def openTagPrefix(name: String, pairs: List[(String, String)]) = pairs.foldLeft(s"<$name")({ case (s, key -> value) => s ++ s" $key=${quoted(value)}" }) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala index 5d29c2947..7c887cef0 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala @@ -9,7 +9,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { type State = XmlWriterState - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,XmlWriterState] = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Array(aNode)) @@ -18,7 +18,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { + override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,State] = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Component(aNode)) @@ -31,7 +31,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { yield s } - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,XmlWriterState] = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Enum(aNode)) @@ -43,13 +43,13 @@ object XmlWriter extends AstStateVisitor with LineUtils { override def defModuleAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Result = { val (_, node, _) = aNode val data = node.data visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,XmlWriterState] = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Port(aNode)) @@ -58,7 +58,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data @@ -71,7 +71,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { } yield s } - override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { + override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]): Either[Error,XmlWriterState] = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Topology(aNode)) @@ -80,7 +80,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def transUnit(s: XmlWriterState, tu: Ast.TransUnit) = + override def transUnit(s: XmlWriterState, tu: Ast.TransUnit): Result = visitList(s, tu.members, matchTuMember) private def writeXmlHeader(fileName: String) = lines( diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriterState.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriterState.scala index 8c86dad8f..42b55dfae 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriterState.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriterState.scala @@ -19,8 +19,8 @@ case class XmlWriterState( /** A mapping from special built-in types to their * default values */ - val zero = Value.Integer(0) - val builtInTypes = Map( + val zero: Value.Integer = Value.Integer(0) + val builtInTypes: Map[String,Value.Integer] = Map( "FwBuffSizeType" -> zero, "FwChanIdType" -> zero, "FwEnumStoreType" -> zero, @@ -120,7 +120,7 @@ case class XmlWriterState( } /** Writes an FPP qualified name as XML */ - def writeQualifiedName(qualifiedName: Name.Qualified) = { + def writeQualifiedName(qualifiedName: Name.Qualified): String = { qualifiedName.toString.replaceAll("\\.", "::") } @@ -170,22 +170,22 @@ case object XmlWriterState extends LineUtils { val defaultDefaultStringSize = 80 /** Gets the generated XML file name for an array definition */ - def getArrayFileName(baseName: String) = s"${baseName}ArrayAi.xml" + def getArrayFileName(baseName: String): String = s"${baseName}ArrayAi.xml" /** Gets the generated XML file name for an enum definition */ - def getEnumFileName(baseName: String) = s"${baseName}EnumAi.xml" + def getEnumFileName(baseName: String): String = s"${baseName}EnumAi.xml" /** Gets the generated XML file name for a component definition */ - def getComponentFileName(baseName: String) = s"${baseName}ComponentAi.xml" + def getComponentFileName(baseName: String): String = s"${baseName}ComponentAi.xml" /** Gets the generated XML file name for a port definition */ - def getPortFileName(baseName: String) = s"${baseName}PortAi.xml" + def getPortFileName(baseName: String): String = s"${baseName}PortAi.xml" /** Gets the generated XML file name for a struct definition */ - def getStructFileName(baseName: String) = s"${baseName}SerializableAi.xml" + def getStructFileName(baseName: String): String = s"${baseName}SerializableAi.xml" /** Gets the generated XML file name for a topology definition */ - def getTopologyFileName(baseName: String) = s"${baseName}TopologyAppAi.xml" + def getTopologyFileName(baseName: String): String = s"${baseName}TopologyAppAi.xml" /** Write an XML comment */ def writeComment(comment: String): List[Line] = diff --git a/compiler/lib/src/main/scala/syntax/Lexer.scala b/compiler/lib/src/main/scala/syntax/Lexer.scala index 0337dacaf..cf0f7ad77 100644 --- a/compiler/lib/src/main/scala/syntax/Lexer.scala +++ b/compiler/lib/src/main/scala/syntax/Lexer.scala @@ -89,7 +89,8 @@ object Lexer extends RegexParsers { // Convert a comment followed by a newline to a newline unitParser(" *(#[^\r\n]*)?\r?\n *".r) - def parseAllInput[T](p: Parser[T]) = new Parser[T] { + def parseAllInput[T](p: Parser[T]): parseAllInput[T] = new parseAllInput[T](p) + class parseAllInput[T](p: Parser[T]) extends Parser[T] { def dropWhile(in: Input, p: Char => Boolean): Input = { if (in.atEnd) in else if (p(in.first)) dropWhile(in.rest, p) @@ -207,15 +208,15 @@ object Lexer extends RegexParsers { } } - val internalError = failure("internal error"): Parser[Token] + val internalError: Parser[Token] = failure("internal error"): Parser[Token] - val newlines = unitParser(rep1(newline)) + val newlines: Parser[Unit] = unitParser(rep1(newline)) - val newlinesOpt = unitParser(rep(newline)) + val newlinesOpt: Parser[Unit] = unitParser(rep(newline)) - val nothing = success(()) + val nothing: Parser[Unit] = success(()) - val reservedWords = List( + val reservedWords: List[(String, Unit => Token)] = List( ("F32", (u: Unit) => Token.F32()), ("F64", (u: Unit) => Token.F64()), ("I16", (u: Unit) => Token.I16()), @@ -303,7 +304,7 @@ object Lexer extends RegexParsers { ("yellow", (u: Unit) => Token.YELLOW()), ) - val symbols = List( + val symbols: List[(Parser[Unit], String, Unit => Token, Parser[Unit])] = List( (newlinesOpt, ")", (u: Unit) => Token.RPAREN(), nothing), (newlinesOpt, "]", (u: Unit) => Token.RBRACKET(), nothing), (newlinesOpt, "}", (u: Unit) => Token.RBRACE(), nothing), diff --git a/compiler/lib/src/main/scala/syntax/Parser.scala b/compiler/lib/src/main/scala/syntax/Parser.scala index 707cad3c5..34bbad8b4 100644 --- a/compiler/lib/src/main/scala/syntax/Parser.scala +++ b/compiler/lib/src/main/scala/syntax/Parser.scala @@ -293,7 +293,7 @@ object Parser extends Parsers { } } - def parseAllInput[T](p: Parser[T]) = new Parser[T] { + def parseAllInput[T](p: Parser[T]): Parser[T] = new Parser[T] { def apply(in: Input) = { val r = p(in) r match { @@ -605,7 +605,7 @@ object Parser extends Parsers { } } - override def commit[T](p: => Parser[T]) = Parser{ in => + override def commit[T](p: => Parser[T]): Parser[T] = Parser{ in => def setError(e: Error) = { error match { case None => { error = Some(e) } diff --git a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala index a2b182790..aa9f0301c 100644 --- a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala +++ b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala @@ -13,7 +13,7 @@ object ResolveSpecInclude extends AstStateTransformer { override def defComponentAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponent]] - ) = { + ): Either[Error,(Out, (List[String], AstNode[Ast.DefComponent], List[String]))] = { val (pre, node1, post) = node val Ast.DefComponent(kind, name, members) = node1.data for { result <- transformList(a, members, componentMember) } @@ -28,7 +28,7 @@ object ResolveSpecInclude extends AstStateTransformer { override def defModuleAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefModule]] - ) = { + ): Either[Error,(Out, (List[String], AstNode[Ast.DefModule], List[String]))] = { val (pre, node1, post) = node val Ast.DefModule(name, members) = node1.data for { result <- transformList(a, members, moduleMember) } @@ -40,7 +40,7 @@ object ResolveSpecInclude extends AstStateTransformer { } } - override def transUnit(a: Analysis, tu: Ast.TransUnit) = { + override def transUnit(a: Analysis, tu: Ast.TransUnit): Either[Error,(Out, Ast.TransUnit)] = { for { result <- transformList(a, tu.members, tuMember) } yield (result._1, Ast.TransUnit(result._2.flatten)) } diff --git a/compiler/lib/src/main/scala/util/Error.scala b/compiler/lib/src/main/scala/util/Error.scala index 220e4a865..35ff4bfbd 100644 --- a/compiler/lib/src/main/scala/util/Error.scala +++ b/compiler/lib/src/main/scala/util/Error.scala @@ -2,26 +2,26 @@ package fpp.compiler.util /** An exception for signaling internal compiler errors */ final case class InternalError(val msg: String) extends Exception { - override def toString = s"internal error: $msg" + override def toString: String = s"internal error: $msg" } /** A data type for handling compilation errors */ sealed trait Error { /** Print the location of a port matching */ - def printMatchingLoc(matchingLoc: Location) = { + def printMatchingLoc(matchingLoc: Location): Unit = { System.err.println("port matching is specified here:") System.err.println(matchingLoc) } /** Print the location of a previous occurrence */ - def printPrevLoc(prevLoc: Location) = { + def printPrevLoc(prevLoc: Location): Unit = { System.err.println("previous occurrence is here:") System.err.println(prevLoc) } /*** Print the error */ - def print = { + def print: Unit = { this match { case SyntaxError(loc, msg) => Error.print (Some(loc)) (msg) case CodeGenError.DuplicateCppFile(file, loc, prevLoc) => @@ -488,10 +488,10 @@ object Error { private var toolOpt: Option[Tool] = None /** Set the tool */ - def setTool(t: Tool) = { toolOpt = Some(t) } + def setTool(t: Tool): Unit = { toolOpt = Some(t) } /** Print an optional value */ - def printOpt[T](opt: T) = { + def printOpt[T](opt: T): Unit = { opt match { case Some(t) => System.err.println(t.toString) case _ => () @@ -499,10 +499,10 @@ object Error { } /** Print the tool */ - def printTool = printOpt(toolOpt) + def printTool: Unit = printOpt(toolOpt) /** Print an optional location and a message */ - def print (locOpt: Option[Location]) (msg: String) = { + def print (locOpt: Option[Location]) (msg: String): Unit = { printTool printOpt(locOpt) System.err.print("error: ") @@ -510,7 +510,7 @@ object Error { } /** Print an XML file and a message */ - def printXml (file: String) (msg: String) = { + def printXml (file: String) (msg: String): Unit = { printTool System.err.println(s"file: $file") System.err.print("error: ") diff --git a/compiler/lib/src/main/scala/util/File.scala b/compiler/lib/src/main/scala/util/File.scala index a3a21c637..44b2993a5 100644 --- a/compiler/lib/src/main/scala/util/File.scala +++ b/compiler/lib/src/main/scala/util/File.scala @@ -3,7 +3,7 @@ package fpp.compiler.util /** A file used in compilation */ sealed trait File { - override def toString = this match { + override def toString: String = this match { case File.Path(p) => p.normalize().toString case File.StdIn => "stdin" } diff --git a/compiler/lib/src/main/scala/util/Location.scala b/compiler/lib/src/main/scala/util/Location.scala index 0a4c03bd3..add8a87ff 100644 --- a/compiler/lib/src/main/scala/util/Location.scala +++ b/compiler/lib/src/main/scala/util/Location.scala @@ -9,7 +9,7 @@ final case class Location( includingLoc: Option[Location] = None /* Location where this location is included */ ) { - override def toString = { + override def toString: String = { def showIncludes(locOpt: Option[Location], s: String): String = { locOpt match { case None => s diff --git a/compiler/lib/src/test/scala/semantics/FormatSpec.scala b/compiler/lib/src/test/scala/semantics/FormatSpec.scala index 9e4ac0a9f..65b08a0ed 100644 --- a/compiler/lib/src/test/scala/semantics/FormatSpec.scala +++ b/compiler/lib/src/test/scala/semantics/FormatSpec.scala @@ -8,7 +8,7 @@ import Helpers._ class FormatSpec extends AnyWordSpec { - def parse(s: String) = Format.Parser.parse(Format.Parser.parseAllInput(Format.Parser.format), s) + def parse(s: String): Format.Parser.ParseResult[Format] = Format.Parser.parse(Format.Parser.parseAllInput(Format.Parser.format), s) "format" should { val ok = List( diff --git a/compiler/lib/src/test/scala/semantics/Helpers.scala b/compiler/lib/src/test/scala/semantics/Helpers.scala index 6a54b7c58..ce6d538f2 100644 --- a/compiler/lib/src/test/scala/semantics/Helpers.scala +++ b/compiler/lib/src/test/scala/semantics/Helpers.scala @@ -6,10 +6,10 @@ import fpp.compiler.analysis._ /** General helpers */ object Helpers { - def annotate[T](x: T) = (List(), x, List()) + def annotate[T](x: T): (List[Nothing], T, List[Nothing]) = (List(), x, List()) - def annotatedNode[T](x: T, id: AstNode.Id) = annotate(AstNode.create(x, id)) + def annotatedNode[T](x: T, id: AstNode.Id): (List[Nothing], AstNode[T], List[Nothing]) = annotate(AstNode.create(x, id)) - def duplicate[T](x: T) = (x, x) + def duplicate[T](x: T): (T, T) = (x, x) } diff --git a/compiler/lib/src/test/scala/semantics/Types.scala b/compiler/lib/src/test/scala/semantics/Types.scala index 02ac4b7f5..822ed5347 100644 --- a/compiler/lib/src/test/scala/semantics/Types.scala +++ b/compiler/lib/src/test/scala/semantics/Types.scala @@ -9,13 +9,13 @@ import Type._ /** Helper functions and values for types */ object Types { - def absType(name: Ast.Ident, id: AstNode.Id = 0) = { + def absType(name: Ast.Ident, id: AstNode.Id = 0): AbsType = { val d = Ast.DefAbsType(name) val anode = annotatedNode(d, id) AbsType(anode) } - def array(name: Ast.Ident, anonArray: AnonArray = AnonArray(None, U32), id: AstNode.Id = 0) = { + def array(name: Ast.Ident, anonArray: AnonArray = AnonArray(None, U32), id: AstNode.Id = 0): Array = { val size = AstNode.create(Ast.ExprLiteralInt("1")) val eltType = AstNode.create(Ast.TypeNameInt(Ast.U32())) val d = Ast.DefArray(name, size, eltType, None, None) @@ -23,21 +23,21 @@ object Types { Array(anode, anonArray) } - def enumeration(name: Ast.Ident, repType: Type.PrimitiveInt = I32, id: AstNode.Id = 0) = { + def enumeration(name: Ast.Ident, repType: Type.PrimitiveInt = I32, id: AstNode.Id = 0): Enum = { val d = Ast.DefEnum(name, None, List(), None) val anode = annotatedNode(d, id) Enum(anode, repType) } - def struct(name: Ast.Ident, anonStruct: AnonStruct = AnonStruct(Map()), id: AstNode.Id = 0) = { + def struct(name: Ast.Ident, anonStruct: AnonStruct = AnonStruct(Map()), id: AstNode.Id = 0): Struct = { val d = Ast.DefStruct(name, List(), None) val anode = annotatedNode(d, id) Struct(anode, anonStruct) } - val defaultAbsType = absType("T", 0) - val defaultArray = array("A", AnonArray(None, I32), 1) - val defaultEnum = enumeration("E", I32, 2) - val defaultStruct = struct("S", AnonStruct(Map()), 3) + val defaultAbsType: AbsType = absType("T", 0) + val defaultArray: Array = array("A", AnonArray(None, I32), 1) + val defaultEnum: Enum = enumeration("E", I32, 2) + val defaultStruct: Struct = struct("S", AnonStruct(Map()), 3) } diff --git a/compiler/lib/src/test/scala/semantics/Values.scala b/compiler/lib/src/test/scala/semantics/Values.scala index cfb72c65f..dc97bd80a 100644 --- a/compiler/lib/src/test/scala/semantics/Values.scala +++ b/compiler/lib/src/test/scala/semantics/Values.scala @@ -8,49 +8,49 @@ import Value._ object Values { - def createI8(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.I8) - def createI16(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.I16) - def createI32(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.I32) - def createI64(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.I64) - def createU8(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.U8) - def createU16(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.U16) - def createU32(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.U32) - def createU64(v: BigInt) = PrimitiveInt(v, Type.PrimitiveInt.U64) - - val defaultI8 = createI8(0) - val defaultI16 = createI16(0) - val defaultI32 = createI32(0) - val defaultI64 = createI64(0) - val defaultU8 = createU8(0) - val defaultU16 = createU16(0) - val defaultU32 = createU32(0) - val defaultU64 = createU64(0) - - val defaultInteger = Integer(0) - - def createF32(v: Double) = Float(v, Type.Float.F32) - def createF64(v: Double) = Float(v, Type.Float.F64) - - val defaultF32 = createF32(0) - val defaultF64 = createF64(0) - - val defaultBoolean = Boolean(false) - - val defaultString = String("") - - def createAnonArray(size: Int, v: Value) = AnonArray(List.fill(size)(v)) - val defaultAnonArray3U32 = createAnonArray(3, defaultU32) - val defaultAnonArray3U32Type = Type.AnonArray(Some(3), Type.U32) - val defaultAnonArray3I32 = AnonArray(List.fill(3)(defaultI32)) - val array = Array(defaultAnonArray3I32, Types.defaultArray) + def createI8(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.I8) + def createI16(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.I16) + def createI32(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.I32) + def createI64(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.I64) + def createU8(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.U8) + def createU16(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.U16) + def createU32(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.U32) + def createU64(v: BigInt): PrimitiveInt = PrimitiveInt(v, Type.PrimitiveInt.U64) + + val defaultI8: PrimitiveInt = createI8(0) + val defaultI16: PrimitiveInt = createI16(0) + val defaultI32: PrimitiveInt = createI32(0) + val defaultI64: PrimitiveInt = createI64(0) + val defaultU8: PrimitiveInt = createU8(0) + val defaultU16: PrimitiveInt = createU16(0) + val defaultU32: PrimitiveInt = createU32(0) + val defaultU64: PrimitiveInt = createU64(0) + + val defaultInteger: Integer = Integer(0) + + def createF32(v: Double): Float = Float(v, Type.Float.F32) + def createF64(v: Double): Float = Float(v, Type.Float.F64) + + val defaultF32: Float = createF32(0) + val defaultF64: Float = createF64(0) + + val defaultBoolean: Boolean = Boolean(false) + + val defaultString: String = String("") + + def createAnonArray(size: Int, v: Value): AnonArray = AnonArray(List.fill(size)(v)) + val defaultAnonArray3U32: AnonArray = createAnonArray(3, defaultU32) + val defaultAnonArray3U32Type: Type.AnonArray = Type.AnonArray(Some(3), Type.U32) + val defaultAnonArray3I32: AnonArray = AnonArray(List.fill(3)(defaultI32)) + val array: Array = Array(defaultAnonArray3I32, Types.defaultArray) val arrayType = Types.defaultArray - val enumeration = EnumConstant(("X", 0), Types.defaultEnum) + val enumeration: EnumConstant = EnumConstant(("X", 0), Types.defaultEnum) val enumType = Types.defaultEnum - val anonStruct = AnonStruct(Map("a" -> defaultU32, "b" -> defaultString)) - val anonStructType = Type.AnonStruct(Map("a" -> Type.U32, "b" -> Type.String(None))) - val structType = Types.struct("S", anonStructType, 3) - val struct = Struct(anonStruct, structType) + val anonStruct: AnonStruct = AnonStruct(Map("a" -> defaultU32, "b" -> defaultString)) + val anonStructType: Type.AnonStruct = Type.AnonStruct(Map("a" -> Type.U32, "b" -> Type.String(None))) + val structType: Type.Struct = Types.struct("S", anonStructType, 3) + val struct: Struct = Struct(anonStruct, structType) } diff --git a/compiler/project/assembly.sbt b/compiler/project/assembly.sbt index 7bc4622d2..c46ce7483 100644 --- a/compiler/project/assembly.sbt +++ b/compiler/project/assembly.sbt @@ -1 +1 @@ -addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.1.0") +addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.2.0") diff --git a/compiler/project/build.properties b/compiler/project/build.properties index 3161d2146..c8fcab543 100644 --- a/compiler/project/build.properties +++ b/compiler/project/build.properties @@ -1 +1 @@ -sbt.version=1.6.1 +sbt.version=1.6.2 diff --git a/compiler/project/scala3-migration.sbt b/compiler/project/scala3-migration.sbt new file mode 100644 index 000000000..e8aca703f --- /dev/null +++ b/compiler/project/scala3-migration.sbt @@ -0,0 +1,2 @@ +// https://docs.scala-lang.org/scala3/guides/migration/scala3-migrate.html +addSbtPlugin("ch.epfl.scala" % "sbt-scala3-migrate" % "0.5.0") From e3fd73aad885d7df1c1a4386b766b4a1ba7ba808 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Sun, 15 May 2022 15:48:20 -0700 Subject: [PATCH 02/14] Fixes after 'migrate lib' - Changed Binop from private to protected[analysis] and all 'binop' methods - Added explicit type annotations on specializations of Value.getType that return a subtype of Type Compiles/tests cleanly with scala 3.1 (thanks to the migrate tool). --- .../src/main/scala/analysis/Analysis.scala | 4 +- .../scala/analysis/Semantics/Command.scala | 6 +- .../main/scala/analysis/Semantics/Event.scala | 2 +- .../main/scala/analysis/Semantics/Param.scala | 2 +- .../analysis/Semantics/PortInstance.scala | 24 +-- .../ResolveTopology/PatternResolver.scala | 2 +- .../scala/analysis/Semantics/TlmChannel.scala | 2 +- .../main/scala/analysis/Semantics/Value.scala | 16 +- compiler/lib/src/main/scala/ast/Ast.scala | 138 +++++++++--------- .../XmlFppWriter/ArrayXmlFppWriter.scala | 4 +- .../XmlFppWriter/ComponentXmlFppWriter.scala | 4 +- .../XmlFppWriter/EnumXmlFppWriter.scala | 4 +- .../XmlFppWriter/PortXmlFppWriter.scala | 8 +- .../XmlFppWriter/StructXmlFppWriter.scala | 8 +- .../XmlFppWriter/TopologyXmlFppWriter.scala | 12 +- .../codegen/XmlFppWriter/XmlFppWriter.scala | 8 +- compiler/lib/src/main/scala/util/File.scala | 2 +- 17 files changed, 123 insertions(+), 123 deletions(-) diff --git a/compiler/lib/src/main/scala/analysis/Analysis.scala b/compiler/lib/src/main/scala/analysis/Analysis.scala index f3c2f8c74..3b90d292b 100644 --- a/compiler/lib/src/main/scala/analysis/Analysis.scala +++ b/compiler/lib/src/main/scala/analysis/Analysis.scala @@ -355,12 +355,12 @@ object Analysis { def checkForDuplicateStructMember[T] (getName: T => Name.Unqualified) (nodes: List[AstNode[T]]): Result.Result[Unit] = - checkForDuplicateNode (getName) (SemanticError.DuplicateStructMember) (nodes) + checkForDuplicateNode (getName) (SemanticError.DuplicateStructMember.apply) (nodes) /** Check for duplicate parameter */ def checkForDuplicateParameter(nodes: Ast.FormalParamList): Result.Result[Unit] = { def getName(param: Ast.FormalParam) = param.name - checkForDuplicateNode (getName) (SemanticError.DuplicateParameter) (nodes.map(_._2)) + checkForDuplicateNode (getName) (SemanticError.DuplicateParameter.apply) (nodes.map(_._2)) } /** Check that int value is nonnegative */ diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala index 495aba7ff..8df0565e5 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala @@ -14,7 +14,7 @@ sealed trait Command { } -final object Command { +object Command { type Opcode = Int @@ -27,7 +27,7 @@ final object Command { def getName = aNode._2.data.name } - final object NonParam { + object NonParam { sealed trait Kind case class Async( @@ -54,7 +54,7 @@ final object Command { } } - final object Param { + object Param { sealed trait Kind case object Get extends Kind diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Event.scala b/compiler/lib/src/main/scala/analysis/Semantics/Event.scala index f2b7da795..d0f00af04 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Event.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Event.scala @@ -18,7 +18,7 @@ final case class Event( } -final object Event { +object Event { type Id = Int diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Param.scala b/compiler/lib/src/main/scala/analysis/Semantics/Param.scala index 091f22755..4d946906b 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Param.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Param.scala @@ -20,7 +20,7 @@ final case class Param( } -final object Param { +object Param { type Id = Int diff --git a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala index 27f26bbe1..3b67c3607 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala @@ -6,7 +6,7 @@ import fpp.compiler.util._ /** An FPP port instance */ sealed trait PortInstance { - override def toString = getUnqualifiedName.toString + override def toString: String = getUnqualifiedName.toString /** Gets the size of the port array */ def getArraySize: Int = 1 @@ -33,16 +33,16 @@ sealed trait PortInstance { } -final object PortInstance { +object PortInstance { /** A port instance type */ sealed trait Type - final object Type { + object Type { final case class DefPort(symbol: Symbol.Port) extends Type { - override def toString = symbol.getUnqualifiedName + override def toString: String = symbol.getUnqualifiedName } - final case object Serial extends Type { - override def toString = "serial" + case object Serial extends Type { + override def toString: String = "serial" } /** Show a type option */ def show(typeOpt: Option[Type]): String = typeOpt match { @@ -61,12 +61,12 @@ final object PortInstance { /** A port direction */ sealed trait Direction - final object Direction { - final case object Input extends Direction { - override def toString = "input" + object Direction { + case object Input extends Direction { + override def toString: String = "input" } - final case object Output extends Direction { - override def toString = "output" + case object Output extends Direction { + override def toString: String = "output" } /** Show a direction option */ def show(dirOpt: Option[Direction]): String = dirOpt match { @@ -83,7 +83,7 @@ final object PortInstance { } } - final object General { + object General { /** A general port kind */ sealed trait Kind diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala index 9e710b974..ebc3a6709 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala @@ -352,7 +352,7 @@ object PatternResolver { } - private final object Health { + private object Health { final case class PingPorts( pingIn: PortInstanceIdentifier, diff --git a/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala b/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala index ef2a954f6..ec3ae186c 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/TlmChannel.scala @@ -21,7 +21,7 @@ final case class TlmChannel( } -final object TlmChannel { +object TlmChannel { type Id = Int diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala index 9c16242bd..c8dceab9b 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala @@ -35,7 +35,7 @@ sealed trait Value { } /** Generic binary operation */ - def binop(op: Value.Binop)(v: Value): Option[Value] = None + protected[analysis] def binop(op: Value.Binop)(v: Value): Option[Value] = None /** Get the type of the value */ def getType: Type @@ -108,7 +108,7 @@ object Value { extends Value { - override def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result1 = op.intOp(value, value1) val result2 = if (kind1 == kind) PrimitiveInt(result1, kind) else Integer(result1) @@ -169,7 +169,7 @@ object Value { (value >= - (u64Bound / 2) && value < u64Bound) } - override def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result = op.intOp(value, value1) Some(Integer(result)) @@ -205,7 +205,7 @@ object Value { /** Floating-point values */ case class Float(value: Double, kind: Type.Float.Kind) extends Value { - override def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { case PrimitiveInt(value1, kind1) => { val result = op.doubleOp(value, value1.toDouble) Some(Float(result.toFloat, Type.Float.F64)) @@ -357,7 +357,7 @@ object Value { /** Enum constant values */ case class EnumConstant(value: (Name.Unqualified, BigInt), t: Type.Enum) extends Value { - override def binop(op: Binop)(v: Value): Option[Value] = convertToRepType.binop(op)(v) + override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = convertToRepType.binop(op)(v) /** Convert the enum to the representation type */ def convertToRepType: PrimitiveInt = PrimitiveInt(value._2, t.repType.kind) @@ -451,7 +451,7 @@ object Value { case _ => None } - override def getType = t + override def getType: Type.Struct = t override def toString: lang.String = anonStruct.toString ++ ": " ++ t.node._2.data.name @@ -468,14 +468,14 @@ object Value { } /** Binary operations */ - private case class Binop( + protected[analysis] case class Binop( /** The integer operation */ intOp: Binop.Op[BigInt], /** The double-precision floating point operation */ doubleOp: Binop.Op[Double] ) - private object Binop { + protected[analysis] object Binop { /** A binary operation */ type Op[T] = (T, T) => T diff --git a/compiler/lib/src/main/scala/ast/Ast.scala b/compiler/lib/src/main/scala/ast/Ast.scala index 16002d692..9f270fa78 100644 --- a/compiler/lib/src/main/scala/ast/Ast.scala +++ b/compiler/lib/src/main/scala/ast/Ast.scala @@ -18,31 +18,31 @@ object Ast { /** Binary operation */ sealed trait Binop - final object Binop { - final case object Add extends Binop { + object Binop { + case object Add extends Binop { override def toString = "+" } - final case object Div extends Binop { + case object Div extends Binop { override def toString = "/" } - final case object Mul extends Binop { + case object Mul extends Binop { override def toString = "*" } - final case object Sub extends Binop { + case object Sub extends Binop { override def toString = "-" } } /** Component kind */ sealed trait ComponentKind - final object ComponentKind { - final case object Active extends ComponentKind { + object ComponentKind { + case object Active extends ComponentKind { override def toString = "active" } - final case object Passive extends ComponentKind { + case object Passive extends ComponentKind { override def toString = "passive" } - final case object Queued extends ComponentKind { + case object Queued extends ComponentKind { override def toString = "queued" } } @@ -189,20 +189,20 @@ object Ast { name: Ident, typeName: AstNode[TypeName] ) - final object FormalParam { + object FormalParam { /** Formal parameter kind */ sealed trait Kind - final case object Ref extends Kind - final case object Value extends Kind + case object Ref extends Kind + case object Value extends Kind } /** Literal bool */ sealed trait LiteralBool object LiteralBool { - final case object True extends LiteralBool { + case object True extends LiteralBool { override def toString = "true" } - final case object False extends LiteralBool { + case object False extends LiteralBool { override def toString = "false" } } @@ -286,14 +286,14 @@ object Ast { /** Queue full behavior */ sealed trait QueueFull - final object QueueFull { - final case object Assert extends QueueFull { + object QueueFull { + case object Assert extends QueueFull { override def toString = "assert" } - final case object Block extends QueueFull { + case object Block extends QueueFull { override def toString = "block" } - final case object Drop extends QueueFull { + case object Drop extends QueueFull { override def toString = "drop" } } @@ -309,13 +309,13 @@ object Ast { ) object SpecCommand { sealed trait Kind - final case object Async extends Kind { + case object Async extends Kind { override def toString = "async" } - final case object Guarded extends Kind { + case object Guarded extends Kind { override def toString = "guarded" } - final case object Sync extends Kind { + case object Sync extends Kind { override def toString = "sync" } } @@ -328,34 +328,34 @@ object Ast { /** Connection graph specifier */ sealed trait SpecConnectionGraph - final object SpecConnectionGraph { + object SpecConnectionGraph { final case class Direct( name: Ident, connections: List[Connection] ) extends SpecConnectionGraph - final object Pattern { + object Pattern { sealed trait Kind - final case object Command extends Kind { + case object Command extends Kind { override def toString = "command" } - final case object Event extends Kind { + case object Event extends Kind { override def toString = "event" } - final case object Health extends Kind { + case object Health extends Kind { override def toString = "health" } - final case object Param extends Kind { + case object Param extends Kind { override def toString = "param" } - final case object Telemetry extends Kind { + case object Telemetry extends Kind { override def toString = "telemetry" } - final case object TextEvent extends Kind { + case object TextEvent extends Kind { override def toString = "text event" } - final case object Time extends Kind { + case object Time extends Kind { override def toString = "time" } } @@ -384,28 +384,28 @@ object Ast { format: AstNode[String], throttle: Option[AstNode[Expr]] ) - final object SpecEvent { + object SpecEvent { /** Event severity */ sealed trait Severity - final case object ActivityHigh extends Severity { + case object ActivityHigh extends Severity { override def toString = "activity high" } - final case object ActivityLow extends Severity { + case object ActivityLow extends Severity { override def toString = "activity low" } - final case object Command extends Severity { + case object Command extends Severity { override def toString = "command" } - final case object Diagnostic extends Severity { + case object Diagnostic extends Severity { override def toString = "diagnostic" } - final case object Fatal extends Severity { + case object Fatal extends Severity { override def toString = "fatal" } - final case object WarningHigh extends Severity { + case object WarningHigh extends Severity { override def toString = "warning high" } - final case object WarningLow extends Severity { + case object WarningLow extends Severity { override def toString = "warning low" } } @@ -436,22 +436,22 @@ object Ast { object SpecLoc { /** Location specifier kind */ sealed trait Kind - final case object Component extends Kind { + case object Component extends Kind { override def toString = "component" } - final case object ComponentInstance extends Kind { + case object ComponentInstance extends Kind { override def toString = "instance" } - final case object Constant extends Kind { + case object Constant extends Kind { override def toString = "constant" } - final case object Port extends Kind { + case object Port extends Kind { override def toString = "port" } - final case object Topology extends Kind { + case object Topology extends Kind { override def toString = "topology" } - final case object Type extends Kind { + case object Type extends Kind { override def toString = "type" } } @@ -482,16 +482,16 @@ object Ast { /** General port instance kind */ sealed trait GeneralKind - final case object AsyncInput extends GeneralKind { + case object AsyncInput extends GeneralKind { override def toString = "async input" } - final case object GuardedInput extends GeneralKind { + case object GuardedInput extends GeneralKind { override def toString = "guarded input" } - final case object Output extends GeneralKind { + case object Output extends GeneralKind { override def toString = "output" } - final case object SyncInput extends GeneralKind { + case object SyncInput extends GeneralKind { override def toString = "sync input" } @@ -503,31 +503,31 @@ object Ast { /** Special port instance kind */ sealed trait SpecialKind - final case object CommandRecv extends SpecialKind { + case object CommandRecv extends SpecialKind { override def toString = "command recv" } - final case object CommandReg extends SpecialKind { + case object CommandReg extends SpecialKind { override def toString = "command reg" } - final case object CommandResp extends SpecialKind { + case object CommandResp extends SpecialKind { override def toString = "command resp" } - final case object Event extends SpecialKind { + case object Event extends SpecialKind { override def toString = "event" } - final case object ParamGet extends SpecialKind { + case object ParamGet extends SpecialKind { override def toString = "param get" } - final case object ParamSet extends SpecialKind { + case object ParamSet extends SpecialKind { override def toString = "param set" } - final case object Telemetry extends SpecialKind { + case object Telemetry extends SpecialKind { override def toString = "telemetry" } - final case object TextEvent extends SpecialKind { + case object TextEvent extends SpecialKind { override def toString = "text event" } - final case object TimeGet extends SpecialKind { + case object TimeGet extends SpecialKind { override def toString = "time get" } @@ -549,14 +549,14 @@ object Ast { low: List[SpecTlmChannel.Limit], high: List[SpecTlmChannel.Limit] ) - final object SpecTlmChannel { + object SpecTlmChannel { /** Telemetry update */ sealed trait Update - final case object Always extends Update { + case object Always extends Update { override def toString = "always" } - final case object OnChange extends Update { + case object OnChange extends Update { override def toString = "on change" } @@ -565,13 +565,13 @@ object Ast { /** Telemetry limit kind */ sealed trait LimitKind - final case object Red extends LimitKind { + case object Red extends LimitKind { override def toString = "red" } - final case object Orange extends LimitKind { + case object Orange extends LimitKind { override def toString = "orange" } - final case object Yellow extends LimitKind { + case object Yellow extends LimitKind { override def toString = "yellow" } @@ -636,24 +636,24 @@ object Ast { final case class TypeNameFloat(name: TypeFloat) extends TypeName final case class TypeNameInt(name: TypeInt) extends TypeName final case class TypeNameQualIdent(name: AstNode[QualIdent]) extends TypeName - final case object TypeNameBool extends TypeName + case object TypeNameBool extends TypeName final case class TypeNameString(size: Option[AstNode[Expr]]) extends TypeName /** Unary operation */ sealed trait Unop - final object Unop { - final case object Minus extends Unop { + object Unop { + case object Minus extends Unop { override def toString = "-" } } /** Visibility */ sealed trait Visibility - final object Visibility { - final case object Private extends Visibility { + object Visibility { + case object Private extends Visibility { override def toString = "private" } - final case object Public extends Visibility { + case object Public extends Visibility { override def toString = "public" } } diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala index 5d136a25c..37d7e3145 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ArrayXmlFppWriter.scala @@ -69,8 +69,8 @@ object ArrayXmlFppWriter extends LineUtils { for (array <- defArrayAnnotated(file)) yield XmlFppWriter.tuMember( array, - Ast.TUMember.DefArray, - Ast.ModuleMember.DefArray, + Ast.TUMember.DefArray.apply, + Ast.ModuleMember.DefArray.apply, file ) diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala index 303d0e2a7..5b33821e2 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala @@ -48,8 +48,8 @@ object ComponentXmlFppWriter extends LineUtils { } yield XmlFppWriter.tuMember( component, - Ast.TUMember.DefComponent, - Ast.ModuleMember.DefComponent, + Ast.TUMember.DefComponent.apply, + Ast.ModuleMember.DefComponent.apply, file ) diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/EnumXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/EnumXmlFppWriter.scala index 604797a5e..7d6be240c 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/EnumXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/EnumXmlFppWriter.scala @@ -77,8 +77,8 @@ object EnumXmlFppWriter extends LineUtils { val aT = (a, data, Nil) XmlFppWriter.tuMember( aT, - Ast.TUMember.DefEnum, - Ast.ModuleMember.DefEnum, + Ast.TUMember.DefEnum.apply, + Ast.ModuleMember.DefEnum.apply, file ) } diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala index 5c9aa2665..c40d1178d 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/PortXmlFppWriter.scala @@ -38,11 +38,11 @@ object PortXmlFppWriter extends LineUtils { } yield XmlFppWriter.tuMemberList( enums, - Ast.TUMember.DefEnum, - Ast.ModuleMember.DefEnum, + Ast.TUMember.DefEnum.apply, + Ast.ModuleMember.DefEnum.apply, port, - Ast.TUMember.DefPort, - Ast.ModuleMember.DefPort, + Ast.TUMember.DefPort.apply, + Ast.ModuleMember.DefPort.apply, file ) diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala index 0b6c881ba..c1a276b56 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/StructXmlFppWriter.scala @@ -83,11 +83,11 @@ object StructXmlFppWriter extends LineUtils { } yield XmlFppWriter.tuMemberList( enums, - Ast.TUMember.DefEnum, - Ast.ModuleMember.DefEnum, + Ast.TUMember.DefEnum.apply, + Ast.ModuleMember.DefEnum.apply, struct, - Ast.TUMember.DefStruct, - Ast.ModuleMember.DefStruct, + Ast.TUMember.DefStruct.apply, + Ast.ModuleMember.DefStruct.apply, file, ) diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/TopologyXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/TopologyXmlFppWriter.scala index 37864c9d7..e0089c933 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/TopologyXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/TopologyXmlFppWriter.scala @@ -22,11 +22,11 @@ object TopologyXmlFppWriter extends LineUtils { } yield XmlFppWriter.tuMemberList( instances, - Ast.TUMember.DefComponentInstance, - Ast.ModuleMember.DefComponentInstance, + Ast.TUMember.DefComponentInstance.apply, + Ast.ModuleMember.DefComponentInstance.apply, top, - Ast.TUMember.DefTopology, - Ast.ModuleMember.DefTopology, + Ast.TUMember.DefTopology.apply, + Ast.ModuleMember.DefTopology.apply, file, ) @@ -170,9 +170,9 @@ object TopologyXmlFppWriter extends LineUtils { Ast.TopologyMember(a1, memberNode, a2) } val instanceMembers = instancesAnnotated.map( - member(Ast.TopologyMember.SpecCompInstance) + member(Ast.TopologyMember.SpecCompInstance.apply) ) - val graphMember = member(Ast.TopologyMember.SpecConnectionGraph)( + val graphMember = member(Ast.TopologyMember.SpecConnectionGraph.apply)( graphAnnotated ) val members = instanceMembers :+ graphMember diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala index 6606a232c..0a12b4cfb 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala @@ -188,8 +188,8 @@ object XmlFppWriter extends LineUtils { file: XmlFppWriter.File ): Ast.TUMember = tuMemberList( Nil: List[Ast.Annotated[Ast.DefEnum]], - Ast.TUMember.DefEnum, - Ast.ModuleMember.DefEnum, + Ast.TUMember.DefEnum.apply, + Ast.ModuleMember.DefEnum.apply, aT, tumConstructor, moduleConstructor, @@ -239,7 +239,7 @@ object XmlFppWriter extends LineUtils { (name: String) (members: List[Ast.Annotated[Ast.ModuleMember.Node]]): Ast.Annotated[Ast.TUMember.Node] = - encloseWithModule(Ast.TUMember.DefModule)(name)(members) + encloseWithModule(Ast.TUMember.DefModule.apply)(name)(members) /** Encloses a list of module members with zero more modules inside a module */ def encloseWithModuleMemberModules @@ -251,7 +251,7 @@ object XmlFppWriter extends LineUtils { (name: String) (members: List[Ast.Annotated[Ast.ModuleMember.Node]]): List[Ast.Annotated[Ast.ModuleMember.Node]] = - List(encloseWithModule(Ast.ModuleMember.DefModule)(name)(members)) + List(encloseWithModule(Ast.ModuleMember.DefModule.apply)(name)(members)) names match { case Nil => members case head :: tail => encloseWithModuleMemberModules(tail)( diff --git a/compiler/lib/src/main/scala/util/File.scala b/compiler/lib/src/main/scala/util/File.scala index 44b2993a5..0cb41918e 100644 --- a/compiler/lib/src/main/scala/util/File.scala +++ b/compiler/lib/src/main/scala/util/File.scala @@ -51,7 +51,7 @@ object File { final case class Path(path: JavaPath) extends File /** Standard input */ - final case object StdIn extends File + case object StdIn extends File /** Get the Java path associated with a string */ def getJavaPath(s: String): JavaPath = From 396349c243679f415037b6d3a0c6050a825454cc Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Sun, 15 May 2022 15:57:40 -0700 Subject: [PATCH 03/14] Finished migration to Scala 3.1.2 except for two warnings: [warn] -- [E121] Pattern Match Warning: C:\opt\local\github.fprime\fpp\compiler\lib\src\main\scala\analysis\Semantics\TypeVisitor.scala:45:11 [warn] 45 | case _ => default(in, t) [warn] | ^ [warn] |Unreachable case except for null (if this is intentional, consider writing case null => instead). [warn] -- [E121] Pattern Match Warning: C:\opt\local\github.fprime\fpp\compiler\lib\src\main\scala\analysis\Semantics\ValueVisitor.scala:45:11 [warn] 45 | case _ => default(in, v) [warn] | ^ [warn] |Unreachable case except for null (if this is intentional, consider writing case null => instead). All tests pass. --- compiler/build.sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/build.sbt b/compiler/build.sbt index fb60cb8f5..321f0516f 100644 --- a/compiler/build.sbt +++ b/compiler/build.sbt @@ -2,7 +2,7 @@ name := "fpp-compiler" ThisBuild / organization := "gov.nasa.jpl" -ThisBuild / scalaVersion := "2.13.6" +ThisBuild / scalaVersion := "3.1.2" lazy val settings = Seq( scalacOptions ++= Seq( From aba3a19318ab0bbe560e40448fb3daec213bf21c Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Sun, 15 May 2022 17:06:19 -0700 Subject: [PATCH 04/14] Removed unreachable cases. Added -Xfatal-warnings. All tests pass --- compiler/build.sbt | 1 + compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala | 1 - .../lib/src/main/scala/analysis/Semantics/ValueVisitor.scala | 1 - 3 files changed, 1 insertion(+), 2 deletions(-) diff --git a/compiler/build.sbt b/compiler/build.sbt index 321f0516f..b206d6fc8 100644 --- a/compiler/build.sbt +++ b/compiler/build.sbt @@ -8,6 +8,7 @@ lazy val settings = Seq( scalacOptions ++= Seq( "-deprecation", "-unchecked", + "-Xfatal-warnings" ), libraryDependencies ++= dependencies, Test / testOptions += Tests.Argument(TestFrameworks.ScalaTest, "-oNCXELOPQRM"), diff --git a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala index 5f06d5515..770542f58 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala @@ -42,7 +42,6 @@ trait TypeVisitor { case t : Type.PrimitiveInt => primitiveInt(in, t) case t : Type.String => string(in, t) case t : Type.Struct => struct(in, t) - case _ => default(in, t) } type In diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala index 3bf5d4f7d..861c2dc67 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala @@ -42,7 +42,6 @@ trait ValueVisitor { case v : Value.EnumConstant => enumConstant(in, v) case v : Value.AnonStruct => anonStruct(in, v) case v : Value.Struct => struct(in, v) - case _ => default(in, v) } } From 49fc431997d99d5669b1b5c9b9fd3ccd5693e4df Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Sun, 15 May 2022 20:56:33 -0700 Subject: [PATCH 05/14] Removed superfluous method override return types. All tests pass --- .../scala/analysis/Analyzers/Analyzer.scala | 2 +- .../Analyzers/ComponentAnalyzer.scala | 2 +- .../analysis/Analyzers/EnumAnalyzer.scala | 2 +- .../analysis/Analyzers/ModuleAnalyzer.scala | 2 +- .../analysis/Analyzers/TopologyAnalyzer.scala | 2 +- .../Analyzers/TypeExpressionAnalyzer.scala | 42 ++++----- .../analysis/Analyzers/UseAnalyzer.scala | 16 ++-- .../CheckSemantics/CheckComponentDefs.scala | 16 ++-- .../CheckComponentInstanceDefs.scala | 4 +- .../CheckSemantics/CheckExprTypes.scala | 46 +++++----- .../CheckSemantics/CheckPortDefs.scala | 2 +- .../CheckSemantics/CheckSpecLocs.scala | 12 +-- .../CheckSemantics/CheckTopologyDefs.scala | 8 +- .../CheckSemantics/CheckTypeUses.scala | 20 ++--- .../CheckSemantics/CheckUseDefCycles.scala | 18 ++-- .../analysis/CheckSemantics/CheckUses.scala | 18 ++-- .../CheckSemantics/EnterSymbols.scala | 22 ++--- .../CheckSemantics/EvalConstantExprs.scala | 26 +++--- .../EvalImpliedEnumConsts.scala | 2 +- .../CheckSemantics/FinalizeTypeDefs.scala | 26 +++--- .../ComputeDependencies/BuildSpecLocMap.scala | 2 +- .../ComputeFrameworkDependencies.scala | 8 +- .../ComputeDependencies/MapUsesToLocs.scala | 12 +-- .../scala/analysis/Semantics/Command.scala | 8 +- .../scala/analysis/Semantics/Component.scala | 2 +- .../Semantics/ComponentInstance.scala | 2 +- .../scala/analysis/Semantics/Connection.scala | 8 +- .../main/scala/analysis/Semantics/Name.scala | 2 +- .../analysis/Semantics/NameSymbolMap.scala | 6 +- .../analysis/Semantics/NestedScope.scala | 12 +-- .../analysis/Semantics/PortInstance.scala | 16 ++-- .../ResolveTopology/PatternResolver.scala | 24 ++--- .../main/scala/analysis/Semantics/Scope.scala | 6 +- .../main/scala/analysis/Semantics/Type.scala | 40 ++++----- .../analysis/Semantics/UseDefMatching.scala | 2 +- .../main/scala/analysis/Semantics/Value.scala | 70 +++++++-------- .../src/main/scala/analysis/UsedSymbols.scala | 12 +-- compiler/lib/src/main/scala/ast/Ast.scala | 4 +- .../src/main/scala/codegen/AstWriter.scala | 88 +++++++++---------- .../codegen/CppWriter/ComputeCppFiles.scala | 10 +-- .../codegen/CppWriter/ConstantCppWriter.scala | 8 +- .../codegen/CppWriter/CppDocCppWriter.scala | 14 +-- .../codegen/CppWriter/CppDocHppWriter.scala | 14 +-- .../scala/codegen/CppWriter/CppWriter.scala | 2 +- .../src/main/scala/codegen/FppWriter.scala | 2 +- .../scala/codegen/LocateDefsFppWriter.scala | 2 +- .../XmlFppWriter/ComponentXmlFppWriter.scala | 4 +- .../codegen/XmlWriter/ArrayXmlWriter.scala | 2 +- .../codegen/XmlWriter/ComputeXmlFiles.scala | 14 +-- .../codegen/XmlWriter/EnumXmlWriter.scala | 2 +- .../codegen/XmlWriter/StructXmlWriter.scala | 2 +- .../codegen/XmlWriter/TypeXmlWriter.scala | 10 +-- .../codegen/XmlWriter/ValueXmlWriter.scala | 16 ++-- .../scala/codegen/XmlWriter/XmlWriter.scala | 14 +-- 54 files changed, 364 insertions(+), 364 deletions(-) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala index 2f02f0e72..d6477520b 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/Analyzer.scala @@ -14,7 +14,7 @@ trait Analyzer extends AstStateVisitor { case None => Right(a) } - override def transUnit(a: Analysis, tu: Ast.TransUnit): Result = + override def transUnit(a: Analysis, tu: Ast.TransUnit) = visitList(a, tu.members, matchTuMember) } diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala index db504851f..32a444623 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/ComponentAnalyzer.scala @@ -9,7 +9,7 @@ trait ComponentAnalyzer extends Analyzer { override def defComponentAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Either[Error,Analysis] = { + ) = { val (_, node1, _) = node val Ast.DefComponent(kind, name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala index 468a5ed77..ba50321f0 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/EnumAnalyzer.scala @@ -12,7 +12,7 @@ trait EnumAnalyzer extends Analyzer { override def defEnumAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val a1 = a.copy(scopeNameList = data.name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala index af1944e65..8cf78d705 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/ModuleAnalyzer.scala @@ -9,7 +9,7 @@ trait ModuleAnalyzer extends Analyzer { override def defModuleAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefModule]] - ): Either[Error,Analysis] = { + ) = { val (_, node1, _) = node val Ast.DefModule(name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala index e3ec17250..fc3ca35ae 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala @@ -9,7 +9,7 @@ trait TopologyAnalyzer extends Analyzer { override def defTopologyAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]] - ): Either[Error,Analysis] = { + ) = { val (_, node1, _) = node val Ast.DefTopology(name, members) = node1.data val a1 = a.copy(scopeNameList = name :: a.scopeNameList) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala index 72eaaff5c..9b718fb08 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala @@ -44,10 +44,10 @@ trait TypeExpressionAnalyzer def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Out = matchTypeNameNode(a, node) - override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString): Out = + override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString) = opt(exprNode)(a, tn.size) - override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,State] = { + override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node1, _) = node val data = node1.data for { @@ -57,7 +57,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]): Either[Error,State] = { + override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = { val (_, node1, _) = node val data = node1.data for { @@ -70,13 +70,13 @@ trait TypeExpressionAnalyzer } yield a } - override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { + override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]) = { val (_, node1, _) = node val data = node1.data exprNode(a, data.value) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node1, _) = node val data = node1.data for { @@ -86,7 +86,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,State] = { + override def defPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node1, _) = node val data = node1.data for { @@ -95,7 +95,7 @@ trait TypeExpressionAnalyzer } yield a } - override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { + override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node1, _) = node val data = node1.data for { @@ -104,25 +104,25 @@ trait TypeExpressionAnalyzer } yield a } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Result = + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = visitList(a, e.elts, exprNode) - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,State] = + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = for { a <- exprNode(a, e.e1) a <- exprNode(a, e.e2) } yield a - override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot): Result = exprNode(a, e.e) + override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot) = exprNode(a, e.e) - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Result = exprNode(a, e.e) + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = exprNode(a, e.e) - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Result = + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = visitList(a, e.members, structMemberNode) - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Result = exprNode(a, e.e) + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = exprNode(a, e.e) - override def specCommandAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCommand]]): Either[Error,State] = { + override def specCommandAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCommand]]) = { val (_, node1, _) = node val data = node1.data for { @@ -133,7 +133,7 @@ trait TypeExpressionAnalyzer } override def specConnectionGraphAnnotatedNode( - a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]): Out = { + a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]) = { def connection(a: Analysis, connection: Ast.SpecConnectionGraph.Connection): Result = { for { a <- opt(exprNode)(a, connection.fromIndex) @@ -148,7 +148,7 @@ trait TypeExpressionAnalyzer } } - override def specEventAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecEvent]]): Either[Error,State] = { + override def specEventAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecEvent]]) = { val (_, node1, _) = node val data = node1.data for { @@ -158,12 +158,12 @@ trait TypeExpressionAnalyzer } yield a } - override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]): Result = { + override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]) = { val data = aNode._2.data exprNode(a, data.phase) } - override def specInternalPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecInternalPort]]): Either[Error,State] = { + override def specInternalPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecInternalPort]]) = { val (_, node1, _) = node val data = node1.data for { @@ -172,7 +172,7 @@ trait TypeExpressionAnalyzer } yield a } - override def specParamAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecParam]]): Either[Error,State] = { + override def specParamAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecParam]]) = { val (_, node1, _) = node val data = node1.data for { @@ -184,7 +184,7 @@ trait TypeExpressionAnalyzer } yield a } - override def specPortInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { + override def specPortInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { val (_, node1, _) = node val data = node1.data data match { @@ -197,7 +197,7 @@ trait TypeExpressionAnalyzer } } - override def specTlmChannelAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]): Either[Error,State] = { + override def specTlmChannelAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = { def limit(a: Analysis, value: Ast.SpecTlmChannel.Limit) = { val (_, e) = value exprNode(a, e) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala index 57afa244c..2cd56fe0e 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala @@ -24,7 +24,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { /** A use of a type definition */ def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = default(a) - override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]): Either[Error,State] = { + override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = { val (_, node1, _) = node val data = node1.data for { @@ -33,7 +33,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } yield a } - override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot): Result = { + override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot) = { def nameOpt(e: Ast.Expr, qualifier: List[Name.Unqualified]): Option[Name.Qualified] = { e match { case Ast.ExprIdent(id) => { @@ -51,19 +51,19 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def exprIdentNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprIdent): Result = { + override def exprIdentNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprIdent) = { val use = Name.Qualified(Nil, e.value) constantUse(a, node, use) } - override def specCompInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCompInstance]]): Result = { + override def specCompInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCompInstance]]) = { val (_, node1, _) = node val data = node1.data qualIdentNode (componentInstanceUse) (a, data.instance) } override def specConnectionGraphAnnotatedNode( - a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]): Out = { + a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]) = { def connection(a: Analysis, connection: Ast.SpecConnectionGraph.Connection): Result = { for { a <- portInstanceIdentifierNode(a, connection.fromPort) @@ -83,7 +83,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { + override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { val (_, node, _) = aNode val data = node.data data match { @@ -115,13 +115,13 @@ trait UseAnalyzer extends TypeExpressionAnalyzer { } } - override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]): Result = { + override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]) = { val (_, node1, _) = node val data = node1.data qualIdentNode(topologyUse)(a, data.top) } - override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent): Result = { + override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent) = { val use = Name.Qualified.fromQualIdent(tn.name.data) typeUse(a, node, use) } diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala index f7bb4e71c..0d999636c 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala @@ -13,7 +13,7 @@ object CheckComponentDefs override def defComponentAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Either[Error,Analysis] = { + ) = { val a1 = a.copy(component = Some(Component(aNode))) for { a <- super.defComponentAnnotatedNode(a1, aNode) @@ -28,7 +28,7 @@ object CheckComponentDefs override def specCommandAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ): Either[Error,Analysis] = { + ) = { val data = aNode._2.data for { opcodeOpt <- a.getIntValueOpt(data.opcode) @@ -41,7 +41,7 @@ object CheckComponentDefs override def specEventAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ): Either[Error,Analysis] = { + ) = { val data = aNode._2.data for { idOpt <- a.getIntValueOpt(data.id) @@ -54,7 +54,7 @@ object CheckComponentDefs override def specInternalPortAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ): Either[Error,Analysis] = { + ) = { val data = aNode._2.data for { instance <- PortInstance.fromSpecInternalPort(a, aNode) @@ -66,7 +66,7 @@ object CheckComponentDefs override def specParamAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ): Either[Error,Analysis] = { + ) = { val data = aNode._2.data val component = a.component.get for { @@ -83,7 +83,7 @@ object CheckComponentDefs override def specPortInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ): Either[Error,Analysis] = { + ) = { for { instance <- PortInstance.fromSpecPortInstance(a, aNode) component <- a.component.get.addPortInstance(instance) @@ -94,7 +94,7 @@ object CheckComponentDefs override def specPortMatchingAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ): Out = { + ) = { val component = a.component.get val list = aNode :: component.specPortMatchingList val component1 = component.copy(specPortMatchingList = list) @@ -104,7 +104,7 @@ object CheckComponentDefs override def specTlmChannelAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ): Either[Error,Analysis] = { + ) = { val data = aNode._2.data for { idOpt <- a.getIntValueOpt(data.id) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala index c4e935922..caf4d0ad9 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentInstanceDefs.scala @@ -12,7 +12,7 @@ object CheckComponentInstanceDefs override def defComponentInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ): Either[Error,Analysis] = + ) = for { ci <- ComponentInstance.fromDefComponentInstance( a, @@ -33,7 +33,7 @@ object CheckComponentInstanceDefs override def specInitAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]] - ): Either[Error,Analysis] = + ) = for { is <- InitSpecifier.fromNode(a, aNode) ci <- a.componentInstance.get.addInitSpecifier(is) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala index 1729b71fa..93a1e63ce 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala @@ -7,10 +7,10 @@ import fpp.compiler.util._ * and default values */ object CheckExprTypes extends UseAnalyzer { - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = visitUse(a, node) - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,State] = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node, _) = aNode val data = node.data for { @@ -29,7 +29,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { val (_, node,_) = aNode if (!a.typeMap.contains(node.id)) { val data = node.data @@ -42,7 +42,7 @@ object CheckExprTypes extends UseAnalyzer { else Right(a) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data for { @@ -60,7 +60,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Either[Error,State] = { + override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { val (_, node, _) = aNode val data = node.data for { @@ -72,7 +72,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val data = node.data for { @@ -90,7 +90,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Either[Error,Analysis] = { + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = { val loc = Locations.get(node.id) val emptyListError = SemanticError.EmptyArray(loc) for { @@ -99,7 +99,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> Type.AnonArray(Some(e.elts.size), t)) } - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,State] = { + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = { val loc = Locations.get(node.id) for { a <- super.exprBinopNode(a, node, e) @@ -108,24 +108,24 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> t) } - override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool): Out = + override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool) = Right(a.assignType(node -> Type.Boolean)) - override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat): Out = + override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat) = Right(a.assignType(node -> Type.F64)) - override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt): Out = + override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt) = Right(a.assignType(node -> Type.Integer)) - override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString): Out = + override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString) = Right(a.assignType(node -> Type.String(None))) - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Either[Error,Analysis] = { + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = { for (a <- super.exprParenNode(a, node, e)) yield a.assignType(node -> a.typeMap(e.e.id)) } - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Either[Error,State] = { + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = { def getName(member: Ast.StructMember) = member.name for { _ <- Analysis.checkForDuplicateStructMember(getName)(e.members) @@ -143,7 +143,7 @@ object CheckExprTypes extends UseAnalyzer { } } - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Either[Error,Analysis] = { + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = { val loc = Locations.get(node.id) for { a <- super.exprUnopNode(a, node, e) @@ -154,7 +154,7 @@ object CheckExprTypes extends UseAnalyzer { } yield a.assignType(node -> t) } - override def specCommandAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]]): Either[Error,State] = { + override def specCommandAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]]) = { val (_, node, _) = aNode val data = node.data for { @@ -165,7 +165,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specEventAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]): Either[Error,State] = { + override def specEventAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]) = { val (_, node, _) = aNode val data = node.data for { @@ -176,7 +176,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]): Either[Error,State] = { + override def specInitAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInit]]) = { val (_, node, _) = aNode val data = node.data for { @@ -186,7 +186,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specInternalPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]]): Either[Error,State] = { + override def specInternalPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]]) = { val (_, node, _) = aNode val data = node.data for { @@ -196,7 +196,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specParamAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]]): Either[Error,State] = { + override def specParamAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecParam]]) = { val (_, node, _) = aNode val data = node.data def checkDefault (a: Analysis) (default: AstNode[Ast.Expr]) = { @@ -215,7 +215,7 @@ object CheckExprTypes extends UseAnalyzer { yield a } - override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]): Out = { + override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = { val (_, node, _) = aNode val data = node.data data match { @@ -230,7 +230,7 @@ object CheckExprTypes extends UseAnalyzer { } } - override def specTlmChannelAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]): Either[Error,State] = { + override def specTlmChannelAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = { val (_, node, _) = aNode val data = node.data def checkLimitExpr (a: Analysis) (e: AstNode[Ast.Expr]): Result.Result[Unit] = { @@ -268,7 +268,7 @@ object CheckExprTypes extends UseAnalyzer { a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ): Either[Error,State] = + ) = for { a <- super.typeNameStringNode(a, node, tn) _ <- convertNodeToNumericOpt(a, tn.size) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala index 3e3e38f35..dbe6f5873 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckPortDefs.scala @@ -9,7 +9,7 @@ object CheckPortDefs with ModuleAnalyzer { - override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,State] = { + override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node, _) = aNode val data = node.data for (_ <- Analysis.checkForDuplicateParameter(data.params)) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala index 183e4a96f..b5ae915e4 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala @@ -9,37 +9,37 @@ object CheckSpecLocs with ModuleAnalyzer { - override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]): Result = { + override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Constant, name, node) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) } - override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Result = { + override def defPortAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Port, name, node) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val name = node.data.name checkSpecLoc(a, Ast.SpecLoc.Type, name, node) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala index 2aa7a6625..5ac95b99a 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala @@ -13,7 +13,7 @@ object CheckTopologyDefs override def defTopologyAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): Either[Error,Analysis] = { + ) = { val symbol = Symbol.Topology(aNode) a.topologyMap.get(symbol) match { case None => @@ -44,7 +44,7 @@ object CheckTopologyDefs override def specCompInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ): Either[Error,Analysis] = { + ) = { val node = aNode._2 val visibility = node.data.visibility val instanceNode = node.data.instance @@ -62,7 +62,7 @@ object CheckTopologyDefs override def specConnectionGraphAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ): Either[Error,Analysis] = { + ) = { for { topology <- aNode._2.data match { case direct: Ast.SpecConnectionGraph.Direct => @@ -82,7 +82,7 @@ object CheckTopologyDefs override def specTopImportAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ): Either[Error,Analysis] = { + ) = { val node = aNode._2 val topNode = node.data.top for { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala index 7def373dd..f1d50071a 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTypeUses.scala @@ -8,7 +8,7 @@ import fpp.compiler.util._ * default value expressions are still unevaluated. */ object CheckTypeUses extends UseAnalyzer { - override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]): Result = { + override def defAbsTypeAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]]) = { val t = Type.AbsType(aNode) val node = aNode._2 @@ -17,7 +17,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = for (a <- super.defArrayAnnotatedNode(a, aNode)) yield { @@ -31,7 +31,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data @@ -68,7 +68,7 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val data = node.data @@ -97,12 +97,12 @@ object CheckTypeUses extends UseAnalyzer { visitIfNeeded(visitor)(a, aNode) } - override def exprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = default(a) + override def exprNode(a: Analysis, node: AstNode[Ast.Expr]) = default(a) - override def typeNameBoolNode(a: Analysis, node: AstNode[Ast.TypeName]): Out = + override def typeNameBoolNode(a: Analysis, node: AstNode[Ast.TypeName]) = Right(a.assignType(node -> Type.Boolean)) - override def typeNameFloatNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat): Out = { + override def typeNameFloatNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat) = { val t = tn.name match { case Ast.F32() => Type.F32 case Ast.F64() => Type.F64 @@ -110,7 +110,7 @@ object CheckTypeUses extends UseAnalyzer { Right(a.assignType(node -> t)) } - override def typeNameIntNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt): Out = { + override def typeNameIntNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt) = { val t = tn.name match { case Ast.I8() => Type.I8 case Ast.I16() => Type.I16 @@ -124,10 +124,10 @@ object CheckTypeUses extends UseAnalyzer { Right(a.assignType(node -> t)) } - override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString): Out = + override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString) = Right(a.assignType(node -> Type.String(tn.size))) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = visitUse(a, node) private def visitUse[T](a: Analysis, node: AstNode[T]): Result = { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala index b29bf6a47..3676d2dd7 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUseDefCycles.scala @@ -6,43 +6,43 @@ import fpp.compiler.util._ /** Check for use-def cycles */ object CheckUseDefCycles extends UseAnalyzer { - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = visitUse(a, node, use) - override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { + override def defArrayAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { val symbol = Symbol.Array(node) visitDefPost(a, symbol, node, super.defArrayAnnotatedNode) } - override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { + override def defConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefConstant]]) = { val symbol = Symbol.Constant(node) visitDefPost(a, symbol, node, super.defConstantAnnotatedNode) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val symbol = Symbol.Enum(node) visitDefPost(a, symbol, node, super.defEnumAnnotatedNode) } - override def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Result = { + override def defEnumConstantAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { val symbol = Symbol.EnumConstant(node) visitDefPost(a, symbol, node, super.defEnumConstantAnnotatedNode) } - override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { + override def defStructAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val symbol = Symbol.Struct(node) visitDefPost(a, symbol, node, super.defStructAnnotatedNode) } - override def defTopologyAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]]): Result = { + override def defTopologyAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]]) = { val symbol = Symbol.Topology(node) visitDefPost(a, symbol, node, super.defTopologyAnnotatedNode) } - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = visitUse(a, node, use) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = visitUse(a, node, use) private def error(a: Analysis, symbol: Symbol): Result = { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala index ca3847a5d..68cf3e30b 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala @@ -6,13 +6,13 @@ import fpp.compiler.util._ /** Match uses to their definitions */ object CheckUses extends UseAnalyzer { - override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = visitQualIdentNode (NameGroup.ComponentInstance) (a, node) - override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = visitQualIdentNode (NameGroup.Component) (a, node) - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = { + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = { def visitExprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = { def visitExprIdent(a: Analysis, node: AstNode[Ast.Expr], name: Name.Unqualified) = { val mapping = a.nestedScope.get (NameGroup.Value) _ @@ -55,7 +55,7 @@ object CheckUses extends UseAnalyzer { visitExprNode(a, node) } - override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,Analysis] = { + override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { val (_, node, _) = aNode val data = node.data for { @@ -69,7 +69,7 @@ object CheckUses extends UseAnalyzer { } yield a.copy(nestedScope = a.nestedScope.pop) } - override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,Analysis] = { + override def defEnumAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node1, _) = node val data = node1.data for { @@ -88,7 +88,7 @@ object CheckUses extends UseAnalyzer { override def defModuleAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Either[Error,Analysis] = { + ) = { val node = aNode._2 val Ast.DefModule(name, members) = node.data for { @@ -106,13 +106,13 @@ object CheckUses extends UseAnalyzer { yield a.copy(nestedScope = a.nestedScope.pop) } - override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = visitQualIdentNode (NameGroup.Port) (a, node) - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = visitQualIdentNode (NameGroup.Topology) (a, node) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = { + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = { val data = node.data data match { case Ast.TypeNameQualIdent(qualIdentNode) => for { diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala index 200e08b30..b904e9332 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala @@ -15,7 +15,7 @@ object EnterSymbols override def defAbsTypeAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -28,7 +28,7 @@ object EnterSymbols override def defArrayAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -41,7 +41,7 @@ object EnterSymbols override def defComponentAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -73,7 +73,7 @@ object EnterSymbols override def defComponentInstanceAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -86,7 +86,7 @@ object EnterSymbols override def defConstantAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -99,7 +99,7 @@ object EnterSymbols override def defEnumAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -130,7 +130,7 @@ object EnterSymbols override def defEnumConstantAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -143,7 +143,7 @@ object EnterSymbols override def defModuleAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val Ast.DefModule(name, members) = node.data val oldScopeNameList = a.scopeNameList @@ -207,7 +207,7 @@ object EnterSymbols override def defPortAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -220,7 +220,7 @@ object EnterSymbols override def defStructAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name @@ -233,7 +233,7 @@ object EnterSymbols override def defTopologyAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): Either[Error,Analysis] = { + ) = { val (_, node, _) = aNode val data = node.data val name = data.name diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala index 322b1cff0..30f2d7183 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalConstantExprs.scala @@ -6,10 +6,10 @@ import fpp.compiler.util._ /** Compute the values of constants symbols and expressions */ object EvalConstantExprs extends UseAnalyzer { - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = visitUse(a, node) - override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]): Result = { + override def defConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefConstant]]) = { val (_, node,_) = aNode if (!a.valueMap.contains(node.id)) { val data = node.data @@ -22,7 +22,7 @@ object EvalConstantExprs extends UseAnalyzer { else Right(a) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,State] = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { def checkForDuplicateValue( a: Analysis, ids: List[AstNode.Id], @@ -47,7 +47,7 @@ object EvalConstantExprs extends UseAnalyzer { } yield a } - override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]): Result = { + override def defEnumConstantAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]]) = { val (_, node, _) = aNode if (!a.valueMap.contains(node.id)) { node.data.value match { @@ -72,7 +72,7 @@ object EvalConstantExprs extends UseAnalyzer { else Right(a) } - override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray): Either[Error,Analysis] = + override def exprArrayNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprArray) = for (a <- super.exprArrayNode(a, node, e)) yield { val eltType = a.typeMap(node.id) match { @@ -88,7 +88,7 @@ object EvalConstantExprs extends UseAnalyzer { a.assignValue(node -> v) } - override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop): Either[Error,Analysis] = + override def exprBinopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprBinop) = for { a <- super.exprBinopNode(a, node, e) v <- e.op match { @@ -99,7 +99,7 @@ object EvalConstantExprs extends UseAnalyzer { } } yield a.assignValue(node -> v) - override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool): Out = { + override def exprLiteralBoolNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool) = { val b = e.value match { case Ast.LiteralBool.True => true case Ast.LiteralBool.False => false @@ -109,29 +109,29 @@ object EvalConstantExprs extends UseAnalyzer { } - override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat): Out = { + override def exprLiteralFloatNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat) = { val v = Value.Float(e.value.toDouble, Type.Float.F64) Right(a.assignValue(node -> v)) } - override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt): Out = { + override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt) = { val bigInt = if (e.value.startsWith("0x") || e.value.startsWith("0X")) BigInt(e.value.substring(2, e.value.length), 16) else BigInt(e.value) val v = Value.Integer(bigInt) Right(a.assignValue(node -> v)) } - override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString): Out = { + override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString) = { val v = Value.String(e.value) Right(a.assignValue(node -> v)) } - override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen): Either[Error,Analysis] = { + override def exprParenNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprParen) = { for (a <- super.exprParenNode(a, node, e)) yield a.assignValue(node -> a.valueMap(e.e.id)) } - override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct): Either[Error,Analysis] = + override def exprStructNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprStruct) = for (a <- super.exprStructNode(a, node, e)) yield { def visitor(members: Value.Struct.Members, node: AstNode[Ast.StructMember]): Value.Struct.Members = { @@ -145,7 +145,7 @@ object EvalConstantExprs extends UseAnalyzer { a.assignValue(node -> v) } - override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop): Either[Error,Analysis] = { + override def exprUnopNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprUnop) = { for (a <- super.exprUnopNode(a, node, e)) yield { val v = a.neg(e.e.id) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala index 7d6622665..015fbe6c2 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/EvalImpliedEnumConsts.scala @@ -10,7 +10,7 @@ object EvalImpliedEnumConsts with ComponentAnalyzer { - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Out = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala index 8158c6c7f..2e5cb6cea 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/FinalizeTypeDefs.scala @@ -9,15 +9,15 @@ object FinalizeTypeDefs extends TypeExpressionAnalyzer { - override def exprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = default(a) + override def exprNode(a: Analysis, node: AstNode[Ast.Expr]) = default(a) - override def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Either[Error,State] = { + override def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]) = { val t1 = a.typeMap(node.id) for (t2 <- TypeVisitor.ty(a, t1)) yield if (t1 != t2) a.assignType(node -> t2) else a } - override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Result = { + override def defArrayAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val symbol = Symbol.Array(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val node = aNode._2 @@ -66,7 +66,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Result = { + override def defEnumAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val symbol = Symbol.Enum(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode @@ -83,7 +83,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Result = { + override def defStructAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val symbol = Symbol.Struct(aNode) def visitor(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode @@ -156,7 +156,7 @@ object FinalizeTypeDefs visitIfNeeded(symbol, visitor)(a, aNode) } - override def transUnit(a: Analysis, tu: Ast.TransUnit): Result = + override def transUnit(a: Analysis, tu: Ast.TransUnit) = super.transUnit(a.copy(visitedSymbolSet = Set()), tu) private def visitIfNeeded[T] @@ -175,21 +175,21 @@ object FinalizeTypeDefs type Out = Result.Result[Type] - override def default(a: Analysis, t: Type): Out = Right(t) + override def default(a: Analysis, t: Type) = Right(t) - override def array(a: Analysis, t: Type.Array): Either[Error,Type] = + override def array(a: Analysis, t: Type.Array) = for (a <- defArrayAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def anonArray(a: Analysis, t: Type.AnonArray): Either[Error,Type.AnonArray] = + override def anonArray(a: Analysis, t: Type.AnonArray) = for (eltType <- ty(a, t.eltType)) yield Type.AnonArray(t.size, eltType) - override def enumeration(a: Analysis, t: Type.Enum): Either[Error,Type] = + override def enumeration(a: Analysis, t: Type.Enum) = for (a <- defEnumAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def string(a: Analysis, t: Type.String): Out = + override def string(a: Analysis, t: Type.String) = t.size match { case Some(e) => { val id = e.id @@ -206,11 +206,11 @@ object FinalizeTypeDefs case None => Right(t) } - override def struct(a: Analysis, t: Type.Struct): Either[Error,Type] = + override def struct(a: Analysis, t: Type.Struct) = for (a <- defStructAnnotatedNode(a, t.node)) yield a.typeMap(t.node._2.id) - override def anonStruct(a: Analysis, t: Type.AnonStruct): Either[Error,Type.AnonStruct] = { + override def anonStruct(a: Analysis, t: Type.AnonStruct) = { def visitor(member: Type.Struct.Member): Result.Result[Type.Struct.Member] = for (memberType <- ty(a, member._2)) yield member._1 -> memberType for (members <- Result.map(t.members.toList, visitor)) diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala index 7b30b8fbd..3e948d766 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/BuildSpecLocMap.scala @@ -9,7 +9,7 @@ object BuildSpecLocMap extends ModuleAnalyzer { override def specLocAnnotatedNode( a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecLoc]] - ): Out = { + ) = { val specNode = node._2 val spec = specNode.data val symbol = spec.symbol diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala index 51d2edb7a..9be432393 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/Framework/ComputeFrameworkDependencies.scala @@ -10,7 +10,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def defComponentAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Result = { + ) = { val (_, node, _) = aNode val data = node.data val d = data.kind match { @@ -27,7 +27,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def defModuleAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Result = { + ) = { val (_, node, _) = aNode val data = node.data visitList(s, data.members, matchModuleMember) @@ -36,7 +36,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { override def specPortInstanceAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ): Out = { + ) = { val (_, node, _) = aNode node.data match { case general: Ast.SpecPortInstance.General => @@ -49,7 +49,7 @@ object ComputeFrameworkDependencies extends AstStateVisitor { } } - override def transUnit(s: State, tu: Ast.TransUnit): Result = + override def transUnit(s: State, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) } diff --git a/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala b/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala index 58556d158..9f4c57645 100644 --- a/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala +++ b/compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala @@ -8,13 +8,13 @@ import fpp.compiler.util._ /** Map uses to locations */ object MapUsesToLocs extends UseAnalyzer { - override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = analyzeUse(a, Ast.SpecLoc.ComponentInstance, use) - override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = analyzeUse(a, Ast.SpecLoc.Component, use) - override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Either[Error,State] = + override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = for { // Analyze as a constant a <- analyzeUse(a, Ast.SpecLoc.Constant, use) @@ -28,13 +28,13 @@ object MapUsesToLocs extends UseAnalyzer { } } yield a - override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = analyzeUse(a, Ast.SpecLoc.Port, use) - override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = + override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) = analyzeUse(a, Ast.SpecLoc.Topology, use) - override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = + override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) = analyzeUse(a, Ast.SpecLoc.Type, use) private def analyzeUse(a: Analysis, kind: Ast.SpecLoc.Kind, use: Name.Qualified): Result = { diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala index 8df0565e5..692850c0f 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Command.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Command.scala @@ -23,8 +23,8 @@ object Command { aNode: Ast.Annotated[AstNode[Ast.SpecCommand]], kind: NonParam.Kind ) extends Command { - def getLoc: Location = Locations.get(aNode._2.id) - def getName = aNode._2.data.name + override def getLoc = Locations.get(aNode._2.id) + override def getName = aNode._2.data.name } object NonParam { @@ -44,8 +44,8 @@ object Command { aNode: Ast.Annotated[AstNode[Ast.SpecParam]], kind: Param.Kind, ) extends Command { - def getLoc: Location = Locations.get(aNode._2.id) - def getName: String = { + override def getLoc = Locations.get(aNode._2.id) + override def getName = { val paramName = aNode._2.data.name.toUpperCase kind match { case Param.Get => s"${paramName}_PARAM_GET" diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala index a7ac2e359..70c98b0fd 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala @@ -419,7 +419,7 @@ object Component { instance2: PortInstance.General ) { - override def toString: String = s"match $instance1 with $instance2" + override def toString = s"match $instance1 with $instance2" /** Gets the location of a port matching */ def getLoc: Location = Locations.get(aNode._2.id) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala index 65820e152..3069157bd 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ComponentInstance.scala @@ -41,7 +41,7 @@ final case class ComponentInstance( /** Gets the location of the component instance */ def getLoc: Location = Locations.get(aNode._2.id) - override def compare(that: ComponentInstance): Int = + override def compare(that: ComponentInstance) = this.qualifiedName.toString.compare(that.qualifiedName.toString) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala b/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala index 343017a55..b6a6cd8a7 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Connection.scala @@ -11,7 +11,7 @@ case class Connection( to: Connection.Endpoint ) extends Ordered[Connection] { - override def toString: String = s"${from.toString} -> ${to.toString}" + override def toString = s"${from.toString} -> ${to.toString}" /** Checks the types of a connection */ def checkTypes: Result.Result[Unit] = { @@ -50,7 +50,7 @@ case class Connection( } /** Compare two connections */ - def compare(that: Connection): Int = { + override def compare(that: Connection) = { val fromCompare = this.from.compare(that.from) if (fromCompare != 0) fromCompare else this.to.compare(that.to) @@ -103,12 +103,12 @@ object Connection { portNumber: Option[Int] = None ) extends Ordered[Endpoint] { - override def toString: String = portNumber match { + override def toString = portNumber match { case Some(n) => s"${port.toString}[${n.toString}]" case None => port.toString } - override def compare(that: Endpoint): Int = { + override def compare(that: Endpoint) = { val name1 = this.port.getQualifiedName.toString val name2 = that.port.getQualifiedName.toString val nameCompare = name1.compare(name2) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Name.scala b/compiler/lib/src/main/scala/analysis/Semantics/Name.scala index 923ffb082..4c6d4fcff 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Name.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Name.scala @@ -14,7 +14,7 @@ object Name { ) { /** Convert a qualified name to a string */ - override def toString: String = { + override def toString = { def f(s1: String, s2: String) = s1 ++ "." ++ s2 def convertQualifier = qualifier match { case Nil => "" diff --git a/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala b/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala index 26573a5d2..1037d948a 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/NameSymbolMap.scala @@ -28,9 +28,9 @@ private case class NameSymbolMapImpl(map: Map[Name.Unqualified,Symbol] = Map()) extends NameSymbolMap { - def apply(name: Name.Unqualified): Symbol = map(name) + override def apply(name: Name.Unqualified) = map(name) - def put(name: Name.Unqualified, symbol: Symbol): Result.Result[NameSymbolMap] = { + override def put(name: Name.Unqualified, symbol: Symbol) = { map.get(name) match { case Some(prevSymbol) => { val loc = symbol.getLoc @@ -41,6 +41,6 @@ private case class NameSymbolMapImpl(map: Map[Name.Unqualified,Symbol] = Map()) } } - def get(name: Name.Unqualified): Option[Symbol] = map.get(name) + override def get(name: Name.Unqualified) = map.get(name) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala b/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala index 6e6c57aa9..4061fedf6 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/NestedScope.scala @@ -37,7 +37,7 @@ private case class NestedScopeImpl(scopes: List[Scope] = List(Scope.empty)) extends NestedScope { - def apply (nameGroup: NameGroup) (name: Name.Unqualified): Symbol = get(nameGroup)(name) match { + override def apply (nameGroup: NameGroup) (name: Name.Unqualified) = get(nameGroup)(name) match { case Some(symbol) => symbol case _ => throw new InternalError(s"could not find symbol for name ${name}") } @@ -47,20 +47,20 @@ private case class NestedScopeImpl(scopes: List[Scope] = List(Scope.empty)) case _ => throw new InternalError("empty scope stack") } - def push(scope: Scope): NestedScopeImpl = NestedScopeImpl(scope :: this.scopes) + override def push(scope: Scope) = NestedScopeImpl(scope :: this.scopes) - def pop: NestedScopeImpl = { + override def pop = { val (_, tail) = splitScopes NestedScopeImpl(tail) } - def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol): Either[Error,NestedScopeImpl] = { + override def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol) = { val (head, tail) = splitScopes for (scope <- head.put(nameGroup)(name, symbol)) yield NestedScopeImpl(scope :: tail) } - def get (nameGroup: NameGroup) (name: Name.Unqualified): Option[Symbol] = { + override def get (nameGroup: NameGroup) (name: Name.Unqualified) = { def helper(scopes: List[Scope]): Option[Symbol] = scopes match { case Nil => None @@ -72,6 +72,6 @@ private case class NestedScopeImpl(scopes: List[Scope] = List(Scope.empty)) helper(this.scopes) } - def innerScope = splitScopes._1 + override def innerScope = splitScopes._1 } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala index 3b67c3607..d6a0da08d 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala @@ -39,10 +39,10 @@ object PortInstance { sealed trait Type object Type { final case class DefPort(symbol: Symbol.Port) extends Type { - override def toString: String = symbol.getUnqualifiedName + override def toString = symbol.getUnqualifiedName } case object Serial extends Type { - override def toString: String = "serial" + override def toString = "serial" } /** Show a type option */ def show(typeOpt: Option[Type]): String = typeOpt match { @@ -63,10 +63,10 @@ object PortInstance { sealed trait Direction object Direction { case object Input extends Direction { - override def toString: String = "input" + override def toString = "input" } case object Output extends Direction { - override def toString: String = "output" + override def toString = "output" } /** Show a direction option */ def show(dirOpt: Option[Direction]): String = dirOpt match { @@ -117,7 +117,7 @@ object PortInstance { override def getNodeId = aNode._2.id - override def getType: Some[Type] = Some(ty) + override def getType = Some(ty) override def getUnqualifiedName = specifier.name @@ -130,7 +130,7 @@ object PortInstance { symbol: Symbol.Port ) extends PortInstance { - override def getDirection: Some[Direction] = { + override def getDirection = { import Ast.SpecPortInstance._ val direction = specifier.kind match { case CommandRecv => Direction.Input @@ -141,7 +141,7 @@ object PortInstance { override def getNodeId = aNode._2.id - override def getType: Some[Type.DefPort] = Some(Type.DefPort(symbol)) + override def getType = Some(Type.DefPort(symbol)) override def getUnqualifiedName = specifier.name @@ -157,7 +157,7 @@ object PortInstance { override def getUnqualifiedName = aNode._2.data.name - override def requireConnectionAt(loc: Location): Result.Result[Unit] = Left( + override def requireConnectionAt(loc: Location) = Left( SemanticError.InvalidPortKind( loc, "cannot connect to internal port", diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala index ebc3a6709..7c66be44d 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PatternResolver.scala @@ -202,14 +202,14 @@ object PatternResolver { def getCmdResponseOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.CommandResp) - override def resolveSource: Either[Error,Source] = + override def resolveSource = for { cmdRegIn <- getCmdRegIn cmdOut <- getCmdOut cmdResponseIn <- getCmdResponseIn } yield Source(cmdRegIn, cmdOut, cmdResponseIn) - override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Target] = + override def resolveTarget(targetUse: (ComponentInstance, Location)) = for { cmdRegOut <- getCmdRegOut(targetUse) cmdIn <- getCmdIn(targetUse) @@ -219,7 +219,7 @@ object PatternResolver { override def getConnectionsForTarget( source: Source, target: Target - ): List[NamedConnection] = { + ) = { val loc = pattern.getLoc List( ("CommandRegistration", connect(loc, target.cmdRegOut, source.cmdRegIn)), @@ -245,20 +245,20 @@ object PatternResolver { type Target = PortInstanceIdentifier - override def resolveSource: Result.Result[PortInstanceIdentifier] = getGeneralPort( + override def resolveSource = getGeneralPort( pattern.source, kind.toString, PortInstance.Direction.Input, portTypeName ) - override def resolveTarget(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = + override def resolveTarget(targetUse: (ComponentInstance, Location)) = getSpecialPort(targetUse, kind) override def getConnectionsForTarget( source: Source, target: Target - ): List[PatternResolver.NamedConnection] = List( + ) = List( (graphName, connect(pattern.getLoc, target, source)) ) @@ -331,15 +331,15 @@ object PatternResolver { } yield Health.PingPorts(pingIn, pingOut) - override def resolveSource: Either[Error,Health.PingPorts] = getPingPorts(pattern.source) + override def resolveSource = getPingPorts(pattern.source) - override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Health.PingPorts] = + override def resolveTarget(targetUse: (ComponentInstance, Location)) = getPingPorts(targetUse) override def getConnectionsForTarget( source: Source, target: Target - ): List[PatternResolver.NamedConnection] = + ) = // Health component does not ping itself if (source.pingOut.componentInstance != target.pingIn.componentInstance) { val loc = pattern.getLoc @@ -398,12 +398,12 @@ object PatternResolver { def getPrmSetOut(targetUse: (ComponentInstance, Location)): Result.Result[PortInstanceIdentifier] = getSpecialPort(targetUse, Ast.SpecPortInstance.ParamSet) - override def resolveSource: Either[Error,Source] = for { + override def resolveSource = for { prmGetIn <- getPrmGetIn prmSetIn <- getPrmSetIn } yield Source(prmGetIn, prmSetIn) - override def resolveTarget(targetUse: (ComponentInstance, Location)): Either[Error,Target] = + override def resolveTarget(targetUse: (ComponentInstance, Location)) = for { prmGetOut <- getPrmGetOut(targetUse) prmSetOut <- getPrmSetOut(targetUse) @@ -412,7 +412,7 @@ object PatternResolver { override def getConnectionsForTarget( source: Source, target: Target - ): List[PatternResolver.NamedConnection] = { + ) = { val loc = pattern.getLoc List( connect(loc, target.prmGetOut, source.prmGetIn), diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala b/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala index e1a4d03f3..c0cbcaa66 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Scope.scala @@ -28,7 +28,7 @@ private case class ScopeImpl(map: Map[NameGroup,NameSymbolMap] = Map()) extends Scope { - def apply (nameGroup: NameGroup) (name: Name.Unqualified): Symbol = + override def apply (nameGroup: NameGroup) (name: Name.Unqualified) = getNameSymbolMap(nameGroup)(name) /** Get the name-symbol map for a name group */ @@ -38,13 +38,13 @@ private case class ScopeImpl(map: Map[NameGroup,NameSymbolMap] = Map()) case None => NameSymbolMap.empty } - def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol): Either[Error,ScopeImpl] = { + override def put (nameGroup: NameGroup) (name: Name.Unqualified, symbol: Symbol) = { val nsm = getNameSymbolMap(nameGroup) for (nsm <- nsm.put(name, symbol)) yield this.copy(map = this.map + (nameGroup -> nsm)) } - def get (nameGroup: NameGroup) (name: Name.Unqualified): Option[Symbol] = + override def get (nameGroup: NameGroup) (name: Name.Unqualified) = getNameSymbolMap(nameGroup).get(name) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala index d64b6fe6b..3d890f33d 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala @@ -61,8 +61,8 @@ object Type { case class PrimitiveInt(kind: PrimitiveInt.Kind) extends Type with Primitive with Int { - override def getDefaultValue: Option[Value.PrimitiveInt] = Some(Value.PrimitiveInt(0, kind)) - override def toString: lang.String = kind match { + override def getDefaultValue = Some(Value.PrimitiveInt(0, kind)) + override def toString = kind match { case PrimitiveInt.I8 => "I8" case PrimitiveInt.I16 => "I16" case PrimitiveInt.I32 => "I32" @@ -97,9 +97,9 @@ object Type { /** Floating-point types */ case class Float(kind: Float.Kind) extends Type with Primitive { - override def getDefaultValue: Option[Value.Float] = Some(Value.Float(0, kind)) + override def getDefaultValue = Some(Value.Float(0, kind)) override def isFloat = true - override def toString: lang.String = kind match { + override def toString = kind match { case Float.F32 => "F32" case Float.F64 => "F64" } @@ -116,22 +116,22 @@ object Type { /** The Boolean type */ case object Boolean extends Type with Primitive { - override def getDefaultValue: Option[Value.Boolean] = Some(Value.Boolean(false)) - override def toString: lang.String = "bool" + override def getDefaultValue = Some(Value.Boolean(false)) + override def toString = "bool" override def isPromotableToArray = true } /** The type of a string */ case class String(size: Option[AstNode[Ast.Expr]]) extends Type { - override def getDefaultValue: Option[Value.String] = Some(Value.String("")) - override def toString: lang.String = "string" + override def getDefaultValue = Some(Value.String("")) + override def toString = "string" override def isPromotableToArray = true } /** The type of arbitrary-width integers */ case object Integer extends Type with Int { - override def getDefaultValue: Option[Value.Integer] = Some(Value.Integer(0)) - override def toString: lang.String = "Integer" + override def getDefaultValue = Some(Value.Integer(0)) + override def toString = "Integer" } /** An abstract type */ @@ -139,9 +139,9 @@ object Type { /** The AST node giving the definition */ node: Ast.Annotated[AstNode[Ast.DefAbsType]] ) extends Type { - override def getDefaultValue: Option[Value.AbsType] = Some(Value.AbsType(this)) - override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) - override def toString: lang.String = node._2.data.name + override def getDefaultValue = Some(Value.AbsType(this)) + override def getDefNodeId = Some(node._2.id) + override def toString = node._2.data.name } /** A named array type */ @@ -159,9 +159,9 @@ object Type { /** Set the size */ def setSize(size: Array.Size): Array = this.copy(anonArray = anonArray.setSize(size)) override def getArraySize = anonArray.getArraySize - override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) + override def getDefNodeId = Some(node._2.id) override def hasNumericMembers = anonArray.hasNumericMembers - override def toString: lang.String = "array " ++ node._2.data.name + override def toString = "array " ++ node._2.data.name } object Array { @@ -198,7 +198,7 @@ object Type { override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) override def isConvertibleToNumeric = true override def isPromotableToArray = true - override def toString: lang.String = "enum " ++ node._2.data.name + override def toString = "enum " ++ node._2.data.name } /** A named struct type */ @@ -217,7 +217,7 @@ object Type { override def getDefaultValue: Option[Value.Struct] = default override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) override def hasNumericMembers = anonStruct.hasNumericMembers - override def toString: lang.String = "struct " ++ node._2.data.name + override def toString = "struct " ++ node._2.data.name } object Struct { @@ -267,7 +267,7 @@ object Type { } override def getArraySize = size override def hasNumericMembers = eltType.hasNumericMembers - override def toString: lang.String = size match { + override def toString = size match { case Some(n) => "[" ++ n.toString ++ "] " ++ eltType.toString case None => "array of " ++ eltType.toString } @@ -293,9 +293,9 @@ object Type { for (members <- defaultMembers(members.toList, Map())) yield Value.AnonStruct(members) } - override def hasNumericMembers: Boolean = + override def hasNumericMembers = members.values.forall(_.hasNumericMembers) - override def toString: lang.String = { + override def toString = { def memberToString(member: Struct.Member) = member._1 ++ ": " ++ member._2.toString members.size match { diff --git a/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala b/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala index 63f35a252..dacf4eab2 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/UseDefMatching.scala @@ -12,7 +12,7 @@ case class UseDefMatching( symbol: Symbol ) { - override def toString: String = { + override def toString = { val useLoc = Locations.get(nodeId) val defLoc = symbol.getLoc val defName = symbol.getUnqualifiedName diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala index c8dceab9b..a11629a4e 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala @@ -108,7 +108,7 @@ object Value { extends Value { - override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result1 = op.intOp(value, value1) val result2 = if (kind1 == kind) PrimitiveInt(result1, kind) else Integer(result1) @@ -124,7 +124,7 @@ object Value { case _ => None } - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value, kind1)) case Type.Integer => Some(Integer(value)) @@ -132,11 +132,11 @@ object Value { case _ => promoteToAggregate(t) } - override def getType: Type.PrimitiveInt = Type.PrimitiveInt(kind) + override def getType = Type.PrimitiveInt(kind) - override def isZero: scala.Boolean = (value == 0) + override def isZero = (value == 0) - override def toString: lang.String = value.toString + ": " + kind.toString + override def toString = value.toString + ": " + kind.toString override def truncate: PrimitiveInt = { def truncateUnsigned(v: BigInt, shiftAmt: Int) = { @@ -169,7 +169,7 @@ object Value { (value >= - (u64Bound / 2) && value < u64Bound) } - override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result = op.intOp(value, value1) Some(Integer(result)) @@ -184,7 +184,7 @@ object Value { case _ => None } - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value, kind1)) case Type.Integer => Some(Integer(value)) @@ -194,9 +194,9 @@ object Value { override def getType = Type.Integer - override def isZero: scala.Boolean = (value == 0) + override def isZero = (value == 0) - override def toString: lang.String = value.toString + override def toString = value.toString override def unary_- = Some(Integer(-value)) @@ -205,7 +205,7 @@ object Value { /** Floating-point values */ case class Float(value: Double, kind: Type.Float.Kind) extends Value { - override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = v match { + override protected[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result = op.doubleOp(value, value1.toDouble) Some(Float(result.toFloat, Type.Float.F64)) @@ -226,20 +226,20 @@ object Value { case _ => None } - override def isZero: scala.Boolean = (Math.abs(value) < Float.EPSILON) + override def isZero = (Math.abs(value) < Float.EPSILON) - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case Type.PrimitiveInt(kind1) => Some(PrimitiveInt(value.intValue, kind1)) case Type.Integer => Some(Integer(value.intValue)) case Type.Float(kind1) => Some(Float(value, kind1)) case _ => promoteToAggregate(t) } - override def getType: Type.Float = Type.Float(kind) + override def getType = Type.Float(kind) - override def toString: lang.String = value.toString + ": " + kind.toString + override def toString = value.toString + ": " + kind.toString - override def truncate: Value = kind match { + override def truncate = kind match { case Type.Float.F32 => Float(value.toFloat, kind) case Type.Float.F64 => this } @@ -258,26 +258,26 @@ object Value { /** Boolean values */ case class Boolean(value: scala.Boolean) extends Value { - override def convertToDistinctType(t: Type): Option[Value] = promoteToAggregate(t) + override def convertToDistinctType(t: Type) = promoteToAggregate(t) override def getType = Type.Boolean - override def toString: lang.String = value.toString + override def toString = value.toString } /** String values */ case class String(value: java.lang.String) extends Value { - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case Type.String(_) => Some(this) case _ => promoteToAggregate(t) } - override def getType: Type.String = Type.String(None) + override def getType = Type.String(None) - override def toString: lang.String = "\"" + value.toString + "\"" + override def toString = "\"" + value.toString + "\"" } @@ -306,16 +306,16 @@ object Value { yield Array(anonArray, arrayType) } - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case anonArrayType : Type.AnonArray => convertToAnonArray(anonArrayType) case arrayType : Type.Array => convertToArray(arrayType) case _ => None } - override def getType: Type.AnonArray = Type.AnonArray(Some(elements.size), elements.head.getType) + override def getType = Type.AnonArray(Some(elements.size), elements.head.getType) - override def toString: lang.String = "[ " ++ elements.mkString(", ") ++ " ]" + override def toString = "[ " ++ elements.mkString(", ") ++ " ]" override def truncate: AnonArray = AnonArray(elements.map(_.truncate)) @@ -326,7 +326,7 @@ object Value { override def getType = t - override def toString: lang.String = s"value of type $t" + override def toString = s"value of type $t" } @@ -339,7 +339,7 @@ object Value { def convertToArray(arrayType: Type.Array): Option[Value.Array] = anonArray.convertToArray(arrayType) - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case anonArrayType : Type.AnonArray => convertToAnonArray(anonArrayType) case arrayType : Type.Array => convertToArray(arrayType) @@ -348,7 +348,7 @@ object Value { override def getType = t - override def toString: lang.String = anonArray.toString ++ ": " ++ t.node._2.data.name + override def toString = anonArray.toString ++ ": " ++ t.node._2.data.name override def truncate: Array = Array(anonArray.truncate, t) @@ -357,12 +357,12 @@ object Value { /** Enum constant values */ case class EnumConstant(value: (Name.Unqualified, BigInt), t: Type.Enum) extends Value { - override protected[analysis] def binop(op: Binop)(v: Value): Option[Value] = convertToRepType.binop(op)(v) + override protected[analysis] def binop(op: Binop)(v: Value) = convertToRepType.binop(op)(v) /** Convert the enum to the representation type */ def convertToRepType: PrimitiveInt = PrimitiveInt(value._2, t.repType.kind) - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = convertToRepType.convertToDistinctType(t) match { case Some(v) => Some(v) case None => promoteToAggregate(t) @@ -372,7 +372,7 @@ object Value { override def isZero = convertToRepType.isZero - override def toString: lang.String = value.toString ++ ": " ++ t.node._2.data.name + override def toString = value.toString ++ ": " ++ t.node._2.data.name override def unary_- = - convertToRepType @@ -406,20 +406,20 @@ object Value { yield Struct(anonStruct, structType) } - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case anonStructType : Type.AnonStruct => convertToAnonStruct(anonStructType) case structType : Type.Struct => convertToStruct(structType) case _ => None } - override def getType: Type.AnonStruct = { + override def getType = { def f(member: Struct.Member): Type.Struct.Member = (member._1, member._2.getType) val typeMembers = members.map(f) Type.AnonStruct(typeMembers) } - override def toString: lang.String = { + override def toString = { def memberToString(member: Struct.Member) = member._1 ++ " = " ++ member._2.toString members.size match { case 0 => "{ }" @@ -444,7 +444,7 @@ object Value { anonStruct.convertToAnonStruct(anonStructType) def convertToStruct(structType: Type.Struct): Option[Value.Struct] = anonStruct.convertToStruct(structType) - override def convertToDistinctType(t: Type): Option[Value] = + override def convertToDistinctType(t: Type) = t match { case anonStructType : Type.AnonStruct => convertToAnonStruct(anonStructType) case structType : Type.Struct => convertToStruct(structType) @@ -453,9 +453,9 @@ object Value { override def getType: Type.Struct = t - override def toString: lang.String = anonStruct.toString ++ ": " ++ t.node._2.data.name + override def toString = anonStruct.toString ++ ": " ++ t.node._2.data.name - override def truncate: Struct = Struct(anonStruct.truncate, t) + override def truncate = Struct(anonStruct.truncate, t) } diff --git a/compiler/lib/src/main/scala/analysis/UsedSymbols.scala b/compiler/lib/src/main/scala/analysis/UsedSymbols.scala index 7c8b070fd..ab743bc2b 100644 --- a/compiler/lib/src/main/scala/analysis/UsedSymbols.scala +++ b/compiler/lib/src/main/scala/analysis/UsedSymbols.scala @@ -10,37 +10,37 @@ object UsedSymbols extends UseAnalyzer { a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) override def componentInstanceUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) override def constantUse( a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) override def topologyUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) override def typeUse( a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) override def portUse( a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified - ): Result = addSymbol(a, node) + ) = addSymbol(a, node) private def addSymbol[T](a: Analysis, node: AstNode[T]) = { val symbol = a.useDefMap(node.id) diff --git a/compiler/lib/src/main/scala/ast/Ast.scala b/compiler/lib/src/main/scala/ast/Ast.scala index 9f270fa78..abce40491 100644 --- a/compiler/lib/src/main/scala/ast/Ast.scala +++ b/compiler/lib/src/main/scala/ast/Ast.scala @@ -226,14 +226,14 @@ object Ast { /** An unqualified identifier */ case class Unqualified(name: Ident) extends QualIdent { - def toIdentList: List[Ident] = List(name) + override def toIdentList = List(name) } /** A qualified identifier */ case class Qualified(qualifier: AstNode[QualIdent], name: AstNode[Ident]) extends QualIdent { - def toIdentList: List[Ident] = qualifier.data.toIdentList ++ List(name.data) + override def toIdentList = qualifier.data.toIdentList ++ List(name.data) } diff --git a/compiler/lib/src/main/scala/codegen/AstWriter.scala b/compiler/lib/src/main/scala/codegen/AstWriter.scala index 9fac4c917..79614752f 100644 --- a/compiler/lib/src/main/scala/codegen/AstWriter.scala +++ b/compiler/lib/src/main/scala/codegen/AstWriter.scala @@ -6,12 +6,16 @@ import fpp.compiler.util._ /** Write out an FPP AST */ object AstWriter extends AstVisitor with LineUtils { + type In = Unit + + type Out = List[Line] + def transUnit(tu: Ast.TransUnit): Out = transUnit((), tu) override def defAbsTypeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ): List[Line] = { + ) = { val (_, node, _) = aNode lines("def abs type") ++ ident(node.data.name).map(indentIn) } @@ -19,7 +23,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defArrayAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def array") ++ @@ -35,7 +39,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defComponentAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -50,7 +54,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defComponentInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def component instance") ++ @@ -70,7 +74,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defConstantAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def constant") ++ @@ -80,7 +84,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defEnumAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def enum") ++ @@ -94,7 +98,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defModuleAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def module") ++ @@ -104,7 +108,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def port") ++ @@ -118,7 +122,7 @@ object AstWriter extends AstVisitor with LineUtils { override def defStructAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def struct") ++ @@ -132,21 +136,21 @@ object AstWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("def topology") ++ (ident(data.name) ++ data.members.map(topologyMember).flatten).map(indentIn) } - override def default(in: Unit): Out = + override def default(in: Unit) = throw new InternalError("AstWriter: Visitor not implemented") override def exprArrayNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprArray - ): List[Line] = + ) = lines("expr array") ++ e.elts.map(exprNode).flatten.map(indentIn) @@ -154,7 +158,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprBinop - ): List[Line] = + ) = lines("expr binop") ++ (exprNode(e.e1) ++ binop(e.op) ++ exprNode(e.e2)).map(indentIn) @@ -162,7 +166,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprDot - ): List[Line] = + ) = lines("expr dot") ++ (exprNode(e.e) ++ ident(e.id.data)).map(indentIn) @@ -170,14 +174,14 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprIdent - ): List[Line] = + ) = ident(e.value) override def exprLiteralBoolNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool - ): List[Line] = { + ) = { val s = e.value match { case Ast.LiteralBool.True => "true" case Ast.LiteralBool.False => "false" @@ -189,28 +193,28 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat - ): List[Line] = + ) = lines("literal float " ++ e.value) override def exprLiteralIntNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt - ): List[Line] = + ) = lines("literal int " ++ e.value) override def exprLiteralStringNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString - ): List[Line] = + ) = addPrefix("literal string", string) (e.value) override def exprParenNode( in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprParen - ): List[Line] = + ) = lines("expr paren") ++ exprNode(e.e).map(indentIn) @@ -218,7 +222,7 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprStruct - ): List[Line] = + ) = lines("expr struct") ++ e.members.map(applyToData(structMember)).flatten.map(indentIn) @@ -226,14 +230,14 @@ object AstWriter extends AstVisitor with LineUtils { in: Unit, node: AstNode[Ast.Expr], e: Ast.ExprUnop - ): List[Line] = + ) = lines("expr unop") ++ (unop(e.op) ++ exprNode(e.e)).map(indentIn) override def specCommandAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec command") ++ @@ -250,7 +254,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specCompInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec comp instance") ++ ( @@ -262,7 +266,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specConnectionGraphAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ): Out = { + ) = { def direct(g: Ast.SpecConnectionGraph.Direct) = { def connection(c: Ast.SpecConnectionGraph.Connection) = { lines("connection") ++ ( @@ -295,7 +299,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specEventAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec event") ++ @@ -312,7 +316,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specIncludeAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInclude]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec include") ++ fileString(data.file.data).map(indentIn) @@ -321,7 +325,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specInternalPortAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec internal port") ++ @@ -336,7 +340,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specLocAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecLoc]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -351,7 +355,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specParamAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec param") ++ @@ -368,7 +372,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specPortInstanceAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ): Out = { + ) = { val (_, node, _) = aNode def general(i: Ast.SpecPortInstance.General) = { val kind = lines(s"kind ${i.kind.toString}") @@ -396,7 +400,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specPortMatchingAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec port matching") ++ @@ -409,7 +413,7 @@ object AstWriter extends AstVisitor with LineUtils { override def specTlmChannelAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ): List[Line] = { + ) = { val (_, node, _) = aNode def update(u: Ast.SpecTlmChannel.Update) = lines(s"update ${u.toString}") @@ -440,43 +444,43 @@ object AstWriter extends AstVisitor with LineUtils { override def specTopImportAnnotatedNode( in: Unit, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec top import") ++ qualIdent(data.top.data).map(indentIn) } - override def transUnit(in: Unit, tu: Ast.TransUnit): List[Line] = + override def transUnit(in: Unit, tu: Ast.TransUnit) = tu.members.map(tuMember).flatten override def typeNameBoolNode( in: Unit, node: AstNode[Ast.TypeName] - ): List[Line] = lines("bool") + ) = lines("bool") override def typeNameFloatNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat - ): List[Line] = lines(tn.name.toString) + ) = lines(tn.name.toString) override def typeNameIntNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt - ): List[Line] = lines(tn.name.toString) + ) = lines(tn.name.toString) override def typeNameQualIdentNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent - ): List[Line] = qualIdent(tn.name.data) + ) = qualIdent(tn.name.data) override def typeNameStringNode( in: Unit, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ): List[Line] = + ) = lines("string") ++ linesOpt(addPrefix("size", exprNode), tn.size).map(indentIn) private def addPrefixNoIndent[T]( @@ -620,8 +624,4 @@ object AstWriter extends AstVisitor with LineUtils { private def visibility(v: Ast.Visibility) = v.toString - type In = Unit - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala index 0bc184ca4..6f6f215a4 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ComputeCppFiles.scala @@ -26,7 +26,7 @@ object ComputeCppFiles extends AstStateVisitor { override def defComponentAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Result = { + ) = { val node = aNode._2 val data = node.data visitList(s, data.members, matchComponentMember) @@ -35,12 +35,12 @@ object ComputeCppFiles extends AstStateVisitor { override def defConstantAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): Either[CodeGenError.DuplicateCppFile,Map[String,Option[Location]]] = addMappings(s, FileNames.getConstants, None) + ) = addMappings(s, FileNames.getConstants, None) override def defModuleAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Result = { + ) = { val node = aNode._2 val data = node.data visitList(s, data.members, matchModuleMember) @@ -49,14 +49,14 @@ object ComputeCppFiles extends AstStateVisitor { override def defTopologyAnnotatedNode( s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): Either[CodeGenError.DuplicateCppFile,Map[String,Option[Location]]] = { + ) = { val node = aNode._2 val name = node.data.name val loc = Locations.get(node.id) addMappings(s, FileNames.getTopology(name), Some(loc)) } - override def transUnit(s: State, tu: Ast.TransUnit): Result = + override def transUnit(s: State, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) /** Adds mappings for hpp and cppfiles */ diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala index 8d1d1c053..874aec5b3 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala @@ -43,7 +43,7 @@ object ConstantCppWriter { override def defConstantAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): List[CppDoc.Member.Lines] = { + ) = { val node = aNode._2 val data = node.data val value = s.a.valueMap(node.id) @@ -81,7 +81,7 @@ object ConstantCppWriter { override def defModuleAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Out = { + ) = { val (_, node, _) = aNode val data = node.data val members = data.members.flatMap(matchModuleMember(s, _)) @@ -96,14 +96,14 @@ object ConstantCppWriter { override def defComponentAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): List[CppDoc.Member] = { + ) = { val (_, node, _) = aNode val data = node.data val members = data.members.flatMap(matchComponentMember(s, _)) members } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit): List[CppDoc.Member] = + override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = tu.members.flatMap(matchTuMember(s, _)) private def writeBooleanConstant(name: String, value: String) = diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala index 89506738c..ee7cd49a8 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocCppWriter.scala @@ -20,14 +20,14 @@ object CppDocCppWriter extends CppDocWriter { } } - override def visitClass(in: Input, c: CppDoc.Class): Output = { + override def visitClass(in: Input, c: CppDoc.Class) = { val name = c.name val newClassNameList = name :: in.classNameList val in1 = in.copy(classNameList = newClassNameList) c.members.map(visitClassMember(in1, _)).flatten } - override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor): List[Line] = { + override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor) = { val unqualifiedClassName = in.getEnclosingClassUnqualified val qualifiedClassName = in.getEnclosingClassQualified val outputLines = { @@ -58,7 +58,7 @@ object CppDocCppWriter extends CppDocWriter { outputLines } - override def visitCppDoc(cppDoc: CppDoc): Output = { + override def visitCppDoc(cppDoc: CppDoc) = { val in = Input(cppDoc.hppFile, cppDoc.cppFileName) List( CppDocWriter.writeBanner( @@ -69,7 +69,7 @@ object CppDocCppWriter extends CppDocWriter { ).flatten } - override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor): List[Line] = { + override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor) = { val unqualifiedClassName = in.getEnclosingClassUnqualified val qualifiedClassName = in.getEnclosingClassQualified val outputLines = { @@ -81,7 +81,7 @@ object CppDocCppWriter extends CppDocWriter { outputLines } - override def visitFunction(in: Input, function: CppDoc.Function): List[Line] = { + override def visitFunction(in: Input, function: CppDoc.Function) = { val contentLines = { val startLines = { val prototypeLines = { @@ -111,7 +111,7 @@ object CppDocCppWriter extends CppDocWriter { Line.blank :: contentLines } - override def visitLines(in: Input, lines: CppDoc.Lines): Output = { + override def visitLines(in: Input, lines: CppDoc.Lines) = { val content = lines.content lines.output match { case CppDoc.Lines.Hpp => Nil @@ -120,7 +120,7 @@ object CppDocCppWriter extends CppDocWriter { } } - override def visitNamespace(in: Input, namespace: CppDoc.Namespace): Output = { + override def visitNamespace(in: Input, namespace: CppDoc.Namespace) = { val name = namespace.name val startLines = List(Line.blank, line(s"namespace $name {")) val outputLines = namespace.members.map(visitNamespaceMember(in, _)).flatten diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala index 8f4c07e03..34bdca850 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppDocHppWriter.scala @@ -51,7 +51,7 @@ object CppDocHppWriter extends CppDocWriter { } } - override def visitClass(in: Input, c: CppDoc.Class): Output = { + override def visitClass(in: Input, c: CppDoc.Class) = { val name = c.name val commentLines = CppDocWriter.writeDoxygenCommentOpt(c.comment) val openLines = c.superclassDecls match { @@ -72,7 +72,7 @@ object CppDocHppWriter extends CppDocWriter { commentLines ++ openLines ++ bodyLines ++ closeLines } - override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor): List[Line] = { + override def visitConstructor(in: Input, constructor: CppDoc.Class.Constructor) = { val unqualifiedClassName = in.getEnclosingClassUnqualified val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(constructor.comment) @@ -85,7 +85,7 @@ object CppDocHppWriter extends CppDocWriter { outputLines } - override def visitCppDoc(cppDoc: CppDoc): Output = { + override def visitCppDoc(cppDoc: CppDoc) = { val hppFile = cppDoc.hppFile val cppFileName = cppDoc.cppFileName val in = Input(hppFile, cppFileName) @@ -100,7 +100,7 @@ object CppDocHppWriter extends CppDocWriter { ).flatten } - override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor): List[Line] = { + override def visitDestructor(in: Input, destructor: CppDoc.Class.Destructor) = { val unqualifiedClassName = in.getEnclosingClassUnqualified val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(destructor.comment) @@ -113,7 +113,7 @@ object CppDocHppWriter extends CppDocWriter { outputLines } - override def visitFunction(in: Input, function: CppDoc.Function): List[Line] = { + override def visitFunction(in: Input, function: CppDoc.Function) = { import CppDoc.Function._ val outputLines = { val lines1 = CppDocWriter.writeDoxygenCommentOpt(function.comment) @@ -145,7 +145,7 @@ object CppDocHppWriter extends CppDocWriter { outputLines } - override def visitLines(in: Input, lines: CppDoc.Lines): Output = { + override def visitLines(in: Input, lines: CppDoc.Lines) = { val content = lines.content lines.output match { case CppDoc.Lines.Hpp => content @@ -154,7 +154,7 @@ object CppDocHppWriter extends CppDocWriter { } } - override def visitNamespace(in: Input, namespace: CppDoc.Namespace): Output = { + override def visitNamespace(in: Input, namespace: CppDoc.Namespace) = { val name = namespace.name val startLines = List(Line.blank, line(s"namespace $name {")) val outputLines = namespace.members.map(visitNamespaceMember(in, _)).flatten diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala index cc7aed183..810cf65fd 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala @@ -28,7 +28,7 @@ object CppWriter extends AstStateVisitor with LineUtils { writeCppDoc(s, cppDoc) } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit): Result = + override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) def tuList(s: CppWriterState, tul: List[Ast.TransUnit]): Either[Error,Unit] = diff --git a/compiler/lib/src/main/scala/codegen/FppWriter.scala b/compiler/lib/src/main/scala/codegen/FppWriter.scala index 7b58b20e6..e3f091e1a 100644 --- a/compiler/lib/src/main/scala/codegen/FppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/FppWriter.scala @@ -185,7 +185,7 @@ object FppWriter extends AstVisitor with LineUtils { List(Line.blank, line("}")) } - override def default(in: Unit): Out = + override def default(in: Unit) = throw new InternalError("FppWriter: Visitor not implemented") override def exprArrayNode( diff --git a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala index 80a45cf98..6863c3417 100644 --- a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala @@ -110,7 +110,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { writeSpecLoc(s, Ast.SpecLoc.Topology, data.name, node) } - override def transUnit(s: State, tu: Ast.TransUnit): List[Line] = + override def transUnit(s: State, tu: Ast.TransUnit) = tu.members.flatMap(matchModuleMember(s, _)) private def writeSpecLoc[T]( diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala index 5b33821e2..3138d04d4 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala @@ -335,7 +335,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "parameter" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[Ast.Annotated[Ast.ComponentMember.Node]]] = { + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { for { enumAnnotatedOpt <- XmlFppWriter.FppBuilder.InlineEnumBuilder.defEnumAnnotatedOpt(file)(xmlNode) comment <- file.getComment(xmlNode) @@ -384,7 +384,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "channel" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[Ast.Annotated[Ast.ComponentMember.Node]]] = { + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { type Limits = List[Ast.SpecTlmChannel.Limit] def translateLimits( direction: String, diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala index 50ea8486e..1c33481ea 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala @@ -9,7 +9,7 @@ object ArrayXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): List[Line] = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val node = aNode._2 val data = node.data val tags = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala index 77ebadb19..1d1a1ec31 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala @@ -16,7 +16,7 @@ object ComputeXmlFiles extends AstStateVisitor { type State = XmlWriterState - override def defArrayAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefArray]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { + override def defArrayAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -25,7 +25,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defComponentAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,XmlWriterState] = { + override def defComponentAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefComponent]]) = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -38,7 +38,7 @@ object ComputeXmlFiles extends AstStateVisitor { yield s } - override def defEnumAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { + override def defEnumAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -56,7 +56,7 @@ object ComputeXmlFiles extends AstStateVisitor { visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefPort]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { + override def defPortAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -65,7 +65,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defStructAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { + override def defStructAnnotatedNode(s: State, node: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node1, _) = node val data = node1.data val loc = Locations.get(node1.id) @@ -74,7 +74,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def defTopologyAnnotatedNode(s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]): Either[CodeGenError.DuplicateXmlFile,XmlWriterState] = { + override def defTopologyAnnotatedNode(s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { val (_, node, _) = aNode val data = node.data val loc = Locations.get(node.id) @@ -83,7 +83,7 @@ object ComputeXmlFiles extends AstStateVisitor { addMapping(s, fileName, loc) } - override def transUnit(s: State, tu: Ast.TransUnit): Result = + override def transUnit(s: State, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) private def addMapping(s: State, fileName: String, loc: Location) = diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala index 1500feeb0..113a4e95a 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala @@ -9,7 +9,7 @@ object EnumXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): List[Line] = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val node = aNode._2 val data = node.data val enumType @ Type.Enum(_, _, _) = s.a.typeMap(node.id) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala index 2b3a97898..bd7135e53 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala @@ -9,7 +9,7 @@ object StructXmlWriter extends AstVisitor with LineUtils { override def default(s: XmlWriterState) = Nil - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): List[Line] = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val node = aNode._2 val data = node.data val tags = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala index 3aebb7e82..77b706f0d 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala @@ -8,17 +8,17 @@ object TypeXmlWriter { private object NameVisitor extends TypeVisitor { - override def absType(s: XmlWriterState, t: Type.AbsType): String = + override def absType(s: XmlWriterState, t: Type.AbsType) = s.writeSymbol(Symbol.AbsType(t.node)) - override def array(s: XmlWriterState, t: Type.Array): String = + override def array(s: XmlWriterState, t: Type.Array) = s.writeSymbol(Symbol.Array(t.node)) override def boolean(s: XmlWriterState) = "bool" - override def default(s: XmlWriterState, t: Type): Out = throw new InternalError("visitor not defined") + override def default(s: XmlWriterState, t: Type) = throw new InternalError("visitor not defined") - override def enumeration(s: XmlWriterState, t: Type.Enum): String = + override def enumeration(s: XmlWriterState, t: Type.Enum) = s.writeSymbol(Symbol.Enum(t.node)) override def float(s: XmlWriterState, t: Type.Float) = t.toString @@ -27,7 +27,7 @@ object TypeXmlWriter { override def string(s: XmlWriterState, t: Type.String) = "string" - override def struct(s: XmlWriterState, t: Type.Struct): String = + override def struct(s: XmlWriterState, t: Type.Struct) = s.writeSymbol(Symbol.Struct(t.node)) type In = XmlWriterState diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala index 87bed7af0..82dcb165f 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala @@ -13,7 +13,7 @@ object ValueXmlWriter { type Out = String - override def absType(s: XmlWriterState, v: Value.AbsType): String = { + override def absType(s: XmlWriterState, v: Value.AbsType) = { val aNode = v.t.node val cppName = s.writeSymbol(Symbol.AbsType(aNode)) s.builtInTypes.get(cppName) match { @@ -22,7 +22,7 @@ object ValueXmlWriter { } } - override def array(s: XmlWriterState, v: Value.Array): String = { + override def array(s: XmlWriterState, v: Value.Array) = { val elements = v.anonArray.elements.map(getValue(s, _)) val stringify = elements.mkString(", ") TypeXmlWriter.getName(s, v.getType) ++ "(" ++ stringify ++ ")" @@ -30,13 +30,13 @@ object ValueXmlWriter { override def boolean(s: XmlWriterState, v: Value.Boolean) = v.value.toString - override def default(s: XmlWriterState, v: Value): Out = + override def default(s: XmlWriterState, v: Value) = throw new InternalError("visitor not defined") - override def enumConstant(s: XmlWriterState, v: Value.EnumConstant): String = + override def enumConstant(s: XmlWriterState, v: Value.EnumConstant) = TypeXmlWriter.getName(s, v.getType) ++ "::" ++ v.value._1.toString - override def float(s: XmlWriterState, v: Value.Float): String = { + override def float(s: XmlWriterState, v: Value.Float) = { val s = v.value.toString v.kind match { case Type.Float.F32 => s"${s}f" @@ -44,17 +44,17 @@ object ValueXmlWriter { } } - override def integer(s: XmlWriterState, v: Value.Integer): String = v.value.toString + override def integer(s: XmlWriterState, v: Value.Integer) = v.value.toString override def primitiveInt(s: XmlWriterState, v: Value.PrimitiveInt) = v.value.toString - override def string(s: XmlWriterState, v: Value.String): String = + override def string(s: XmlWriterState, v: Value.String) = "\"" ++ v.value.toString.replaceAll("\\\\", "\\\\\\\\"). replaceAll("\"", "\\\\\"").replaceAll("\n", "\\\\n") ++ "\"" - override def struct(s: XmlWriterState, v: Value.Struct): String = { + override def struct(s: XmlWriterState, v: Value.Struct) = { val structType = v.getType val data = structType.node._2.data val namesList = data.members diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala index 7c887cef0..935820612 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala @@ -9,7 +9,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { type State = XmlWriterState - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]): Either[Error,XmlWriterState] = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Array(aNode)) @@ -18,7 +18,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]): Either[Error,State] = { + override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Component(aNode)) @@ -31,7 +31,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { yield s } - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]): Either[Error,XmlWriterState] = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Enum(aNode)) @@ -49,7 +49,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]): Either[Error,XmlWriterState] = { + override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Port(aNode)) @@ -58,7 +58,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]): Either[Error,State] = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data @@ -71,7 +71,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { } yield s } - override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]): Either[Error,XmlWriterState] = { + override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Topology(aNode)) @@ -80,7 +80,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def transUnit(s: XmlWriterState, tu: Ast.TransUnit): Result = + override def transUnit(s: XmlWriterState, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) private def writeXmlHeader(fileName: String) = lines( From ed15ee18684f6384a5df48ba8afa67eafde6df85 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Mon, 16 May 2022 10:02:37 -0700 Subject: [PATCH 06/14] updated install script --- compiler/install | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/compiler/install b/compiler/install index 22f35e32e..88e272216 100755 --- a/compiler/install +++ b/compiler/install @@ -7,6 +7,8 @@ # FPP_SBT_FLAGS # ---------------------------------------------------------------------- +scala_version="3.1.2" + if test $# -gt 1 then echo 'usage: install dest-dir' 1>&2 @@ -61,7 +63,8 @@ mkdir -p $dest echo "Installing tools at $dest" for tool in $tools do - jar=`find tools/$tool -name "*$name*assembly*.jar"` + jar=`find tools/$tool -name "*$name*assembly*.jar" | grep "target/scala-$scala_version"` + echo " $jar" cp $jar $dest/$tool.jar echo '#!/bin/sh From 515f3792e04f6240e983edcf88adbbc620df7eb8 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Mon, 16 May 2022 10:03:02 -0700 Subject: [PATCH 07/14] Removed more override methods return types. --- .../scala/codegen/CppWriter/CppWriter.scala | 4 +-- .../XmlFppWriter/ComponentXmlFppWriter.scala | 10 +++---- .../XmlWriter/ComponentXmlWriter.scala | 10 +++---- .../codegen/XmlWriter/ComputeXmlFiles.scala | 2 +- .../codegen/XmlWriter/PortXmlWriter.scala | 14 +++++----- .../codegen/XmlWriter/StructXmlWriter.scala | 16 ++++++------ .../codegen/XmlWriter/TopologyXmlWriter.scala | 20 +++++++------- .../codegen/XmlWriter/TypeXmlWriter.scala | 26 +++++++++---------- .../codegen/XmlWriter/ValueXmlWriter.scala | 20 +++++++------- .../lib/src/main/scala/syntax/Parser.scala | 10 +++---- .../scala/transform/ResolveSpecInclude.scala | 16 ++++++------ compiler/lib/src/main/scala/util/Error.scala | 2 +- compiler/lib/src/main/scala/util/File.scala | 2 +- .../lib/src/main/scala/util/Location.scala | 2 +- 14 files changed, 77 insertions(+), 77 deletions(-) diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala index 810cf65fd..a7fafc42e 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala @@ -12,7 +12,7 @@ object CppWriter extends AstStateVisitor with LineUtils { override def defModuleAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Result = { + ) = { val node = aNode._2 val data = node.data visitList(s, data.members, matchModuleMember) @@ -21,7 +21,7 @@ object CppWriter extends AstStateVisitor with LineUtils { override def defTopologyAnnotatedNode( s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): Either[Error,CppWriterState] = { + ) = { val node = aNode._2 val data = node.data val cppDoc = TopologyCppWriter(s, aNode).write diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala index 3138d04d4..5961ce8e0 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala @@ -127,7 +127,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "import_dictionary" - override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,(List[String], Ast.ComponentMember.SpecInclude, Nil.type)] = + override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = for { child <- file.getUniqueChild(xmlNode) } @@ -199,7 +199,7 @@ object ComponentXmlFppWriter extends LineUtils { yield Special(kind, name) } - override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,(List[String], Ast.ComponentMember.SpecPortInstance, Nil.type)] = { + override def generateMemberNode(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = { for { comment <- file.getComment(xmlNode) member <- XmlFppWriter.getAttributeOpt(xmlNode, "role") match { @@ -220,7 +220,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "internal_interface" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = for { annotatedEnumMemberNodes <- translateArgEnums(file, xmlNode) comment <- file.getComment(xmlNode) @@ -245,7 +245,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "command" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = for { xmlKind <- file.getAttribute(xmlNode, "kind") kind <- xmlKind match { @@ -285,7 +285,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "event" - override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,List[(List[String], Ast.ComponentMember.Node, List[String])]] = + override def generateMemberNodes(file: XmlFppWriter.File, xmlNode: scala.xml.Node) = for { annotatedEnumMemberNodes <- translateArgEnums(file, xmlNode) comment <- file.getComment(xmlNode) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala index 091e74e0a..d77c09dc5 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala @@ -7,10 +7,14 @@ import fpp.compiler.util._ /** Write out F Prime XML for component definitions */ object ComponentXmlWriter extends AstVisitor with LineUtils { + type In = XmlWriterState + + type Out = List[Line] + override def defComponentAnnotatedNode( s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): List[Line] = { + ) = { val symbol = Symbol.Component(aNode) val c = s.a.componentMap(symbol) val pairs = { @@ -313,8 +317,4 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("telemetry") (tlmChannels.map(indentIn)) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala index 1d1a1ec31..38f3763e7 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComputeXmlFiles.scala @@ -50,7 +50,7 @@ object ComputeXmlFiles extends AstStateVisitor { override def defModuleAnnotatedNode( s: State, node: Ast.Annotated[AstNode[Ast.DefModule]] - ): Result = { + ) = { val (_, node1, _) = node val data = node1.data visitList(s, data.members, matchModuleMember) diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala index 2f30a6d3c..8a0c7485f 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala @@ -7,12 +7,16 @@ import fpp.compiler.util._ /** Write out F Prime XML for port definitions */ object PortXmlWriter extends AstVisitor with LineUtils { - override def default(s: XmlWriterState) = Nil + type In = XmlWriterState + + type Out = List[Line] + + override def default(s: In) = Nil override def defPortAnnotatedNode( - s: XmlWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ): List[Line] = { + ) = { val node = aNode._2 val data = node.data val tags = { @@ -38,8 +42,4 @@ object PortXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines(tags)(body.map(indentIn)) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala index bd7135e53..0f276a1f3 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala @@ -7,9 +7,13 @@ import fpp.compiler.util._ /** Write out F Prime XML for struct definitions */ object StructXmlWriter extends AstVisitor with LineUtils { - override def default(s: XmlWriterState) = Nil + type In = XmlWriterState + + type Out = List[Line] + + override def default(s: In) = Nil - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val node = aNode._2 val data = node.data val tags = { @@ -32,10 +36,10 @@ object StructXmlWriter extends AstVisitor with LineUtils { } def structTypeMemberAnnotatedNode( - s: XmlWriterState, + s: In, structType: Type.Struct, aNode: Ast.Annotated[AstNode[Ast.StructTypeMember]] - ): List[Line] = { + ): Out = { val node = aNode._2 val data = node.data val t = s.a.typeMap(data.typeName.id) @@ -69,8 +73,4 @@ object StructXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines("member", pairs) (body.map(indentIn)) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala index 2b9f26a23..94beded6a 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala @@ -7,10 +7,14 @@ import fpp.compiler.util._ /** Write out F Prime XML for topology definitions */ object TopologyXmlWriter extends AstVisitor with LineUtils { + type In = XmlWriterState + + type Out = List[Line] + override def defTopologyAnnotatedNode( - s: XmlWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): List[Line] = { + ) = { val symbol = Symbol.Topology(aNode) val t = s.a.topologyMap(symbol) val data = aNode._2.data @@ -25,14 +29,14 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines ("assembly", pairs) (body.map(indentIn)) } - override def default(s: XmlWriterState) = Nil + override def default(s: In) = Nil - private def writeImports(s: XmlWriterState, t: Topology) = { + private def writeImports(s: In, t: Topology) = { val symbols = t.instanceMap.keys.map(ci => Symbol.Component(ci.component.aNode)) s.writeImportDirectives(symbols) } - private def writeInstances(s: XmlWriterState, t: Topology) = { + private def writeInstances(s: In, t: Topology) = { def writeInstance(ci: ComponentInstance) = { val cis = Symbol.ComponentInstance(ci.aNode) val cs = Symbol.Component(ci.component.aNode) @@ -54,7 +58,7 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { instances.flatMap(writeInstance).toList } - private def writeConnections(s: XmlWriterState, t: Topology) = { + private def writeConnections(s: In, t: Topology) = { def getPairs( endpoint: Connection.Endpoint, portNumber: Int @@ -92,8 +96,4 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { Line.blankSeparated (writeGraph) (t.connectionMap.keys.toList.sorted) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala index 77b706f0d..5a2324579 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala @@ -8,32 +8,32 @@ object TypeXmlWriter { private object NameVisitor extends TypeVisitor { - override def absType(s: XmlWriterState, t: Type.AbsType) = + type In = XmlWriterState + + type Out = String + + override def absType(s: In, t: Type.AbsType) = s.writeSymbol(Symbol.AbsType(t.node)) - override def array(s: XmlWriterState, t: Type.Array) = + override def array(s: In, t: Type.Array) = s.writeSymbol(Symbol.Array(t.node)) - override def boolean(s: XmlWriterState) = "bool" + override def boolean(s: In) = "bool" - override def default(s: XmlWriterState, t: Type) = throw new InternalError("visitor not defined") + override def default(s: In, t: Type) = throw new InternalError("visitor not defined") - override def enumeration(s: XmlWriterState, t: Type.Enum) = + override def enumeration(s: In, t: Type.Enum) = s.writeSymbol(Symbol.Enum(t.node)) - override def float(s: XmlWriterState, t: Type.Float) = t.toString + override def float(s: In, t: Type.Float) = t.toString - override def primitiveInt(s: XmlWriterState, t: Type.PrimitiveInt) = t.toString + override def primitiveInt(s: In, t: Type.PrimitiveInt) = t.toString - override def string(s: XmlWriterState, t: Type.String) = "string" + override def string(s: In, t: Type.String) = "string" - override def struct(s: XmlWriterState, t: Type.Struct) = + override def struct(s: In, t: Type.Struct) = s.writeSymbol(Symbol.Struct(t.node)) - type In = XmlWriterState - - type Out = String - } /** Get the name of a type */ diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala index 82dcb165f..ff295acfe 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala @@ -13,7 +13,7 @@ object ValueXmlWriter { type Out = String - override def absType(s: XmlWriterState, v: Value.AbsType) = { + override def absType(s: In, v: Value.AbsType) = { val aNode = v.t.node val cppName = s.writeSymbol(Symbol.AbsType(aNode)) s.builtInTypes.get(cppName) match { @@ -22,21 +22,21 @@ object ValueXmlWriter { } } - override def array(s: XmlWriterState, v: Value.Array) = { + override def array(s: In, v: Value.Array) = { val elements = v.anonArray.elements.map(getValue(s, _)) val stringify = elements.mkString(", ") TypeXmlWriter.getName(s, v.getType) ++ "(" ++ stringify ++ ")" } - override def boolean(s: XmlWriterState, v: Value.Boolean) = v.value.toString + override def boolean(s: In, v: Value.Boolean) = v.value.toString - override def default(s: XmlWriterState, v: Value) = + override def default(s: In, v: Value) = throw new InternalError("visitor not defined") - override def enumConstant(s: XmlWriterState, v: Value.EnumConstant) = + override def enumConstant(s: In, v: Value.EnumConstant) = TypeXmlWriter.getName(s, v.getType) ++ "::" ++ v.value._1.toString - override def float(s: XmlWriterState, v: Value.Float) = { + override def float(s: In, v: Value.Float) = { val s = v.value.toString v.kind match { case Type.Float.F32 => s"${s}f" @@ -44,17 +44,17 @@ object ValueXmlWriter { } } - override def integer(s: XmlWriterState, v: Value.Integer) = v.value.toString + override def integer(s: In, v: Value.Integer) = v.value.toString - override def primitiveInt(s: XmlWriterState, v: Value.PrimitiveInt) = v.value.toString + override def primitiveInt(s: In, v: Value.PrimitiveInt) = v.value.toString - override def string(s: XmlWriterState, v: Value.String) = + override def string(s: In, v: Value.String) = "\"" ++ v.value.toString.replaceAll("\\\\", "\\\\\\\\"). replaceAll("\"", "\\\\\"").replaceAll("\n", "\\\\n") ++ "\"" - override def struct(s: XmlWriterState, v: Value.Struct) = { + override def struct(s: In, v: Value.Struct) = { val structType = v.getType val data = structType.node._2.data val namesList = data.members diff --git a/compiler/lib/src/main/scala/syntax/Parser.scala b/compiler/lib/src/main/scala/syntax/Parser.scala index 34bbad8b4..5b3b273c3 100644 --- a/compiler/lib/src/main/scala/syntax/Parser.scala +++ b/compiler/lib/src/main/scala/syntax/Parser.scala @@ -9,10 +9,10 @@ import scala.util.parsing.input.{NoPosition, Position, Reader} object Parser extends Parsers { class TokenReader(tokens: Seq[Token]) extends Reader[Token] { - override def first: Token = tokens.head - override def atEnd: Boolean = tokens.isEmpty - override def pos: Position = tokens.headOption.map(_.pos).getOrElse(NoPosition) - override def rest: Reader[Token] = new TokenReader(tokens.tail) + override def first = tokens.head + override def atEnd = tokens.isEmpty + override def pos = tokens.headOption.map(_.pos).getOrElse(NoPosition) + override def rest = new TokenReader(tokens.tail) } def componentKind: Parser[Ast.ComponentKind] = { @@ -605,7 +605,7 @@ object Parser extends Parsers { } } - override def commit[T](p: => Parser[T]): Parser[T] = Parser{ in => + override def commit[T](p: => Parser[T]) = Parser{ in => def setError(e: Error) = { error match { case None => { error = Some(e) } diff --git a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala index aa9f0301c..94921a6db 100644 --- a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala +++ b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala @@ -8,12 +8,14 @@ import fpp.compiler.util._ /** Resolve include specifiers */ object ResolveSpecInclude extends AstStateTransformer { - def default(a: Analysis) = a + type State = Analysis + + def default(a: In) = a override def defComponentAnnotatedNode( - a: Analysis, + a: In, node: Ast.Annotated[AstNode[Ast.DefComponent]] - ): Either[Error,(Out, (List[String], AstNode[Ast.DefComponent], List[String]))] = { + ) = { val (pre, node1, post) = node val Ast.DefComponent(kind, name, members) = node1.data for { result <- transformList(a, members, componentMember) } @@ -26,9 +28,9 @@ object ResolveSpecInclude extends AstStateTransformer { } override def defModuleAnnotatedNode( - a: Analysis, + a: In, node: Ast.Annotated[AstNode[Ast.DefModule]] - ): Either[Error,(Out, (List[String], AstNode[Ast.DefModule], List[String]))] = { + ) = { val (pre, node1, post) = node val Ast.DefModule(name, members) = node1.data for { result <- transformList(a, members, moduleMember) } @@ -40,7 +42,7 @@ object ResolveSpecInclude extends AstStateTransformer { } } - override def transUnit(a: Analysis, tu: Ast.TransUnit): Either[Error,(Out, Ast.TransUnit)] = { + override def transUnit(a: In, tu: Ast.TransUnit) = { for { result <- transformList(a, tu.members, tuMember) } yield (result._1, Ast.TransUnit(result._2.flatten)) } @@ -130,6 +132,4 @@ object ResolveSpecInclude extends AstStateTransformer { private def tuMember(a: Analysis, tum: Ast.TUMember) = moduleMember(a, tum) - type State = Analysis - } diff --git a/compiler/lib/src/main/scala/util/Error.scala b/compiler/lib/src/main/scala/util/Error.scala index 35ff4bfbd..4d2feebc2 100644 --- a/compiler/lib/src/main/scala/util/Error.scala +++ b/compiler/lib/src/main/scala/util/Error.scala @@ -2,7 +2,7 @@ package fpp.compiler.util /** An exception for signaling internal compiler errors */ final case class InternalError(val msg: String) extends Exception { - override def toString: String = s"internal error: $msg" + override def toString = s"internal error: $msg" } /** A data type for handling compilation errors */ diff --git a/compiler/lib/src/main/scala/util/File.scala b/compiler/lib/src/main/scala/util/File.scala index 0cb41918e..e02578429 100644 --- a/compiler/lib/src/main/scala/util/File.scala +++ b/compiler/lib/src/main/scala/util/File.scala @@ -3,7 +3,7 @@ package fpp.compiler.util /** A file used in compilation */ sealed trait File { - override def toString: String = this match { + override def toString = this match { case File.Path(p) => p.normalize().toString case File.StdIn => "stdin" } diff --git a/compiler/lib/src/main/scala/util/Location.scala b/compiler/lib/src/main/scala/util/Location.scala index add8a87ff..0a4c03bd3 100644 --- a/compiler/lib/src/main/scala/util/Location.scala +++ b/compiler/lib/src/main/scala/util/Location.scala @@ -9,7 +9,7 @@ final case class Location( includingLoc: Option[Location] = None /* Location where this location is included */ ) { - override def toString: String = { + override def toString = { def showIncludes(locOpt: Option[Location], s: String): String = { locOpt match { case None => s From 6c9e32403f144e861d565abacf6a2ce64dab68cb Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Mon, 16 May 2022 13:28:02 -0700 Subject: [PATCH 08/14] Finished removing superfluous override method return types. --- .../CheckSemantics/CheckExprTypes.scala | 2 +- .../analysis/Semantics/PortInstance.scala | 4 +- .../main/scala/analysis/Semantics/Type.scala | 4 +- .../src/main/scala/ast/AstStateVisitor.scala | 2 +- .../src/main/scala/codegen/AstWriter.scala | 102 ++++----- .../scala/codegen/ComputeGeneratedFiles.scala | 4 +- .../codegen/CppWriter/ConstantCppWriter.scala | 18 +- .../src/main/scala/codegen/FppWriter.scala | 202 +++++++++--------- .../src/main/scala/codegen/Indentation.scala | 2 +- .../lib/src/main/scala/codegen/Line.scala | 2 +- .../scala/codegen/LocateDefsFppWriter.scala | 56 ++--- .../codegen/XmlWriter/ArrayXmlWriter.scala | 16 +- .../XmlWriter/ComponentXmlWriter.scala | 18 +- .../codegen/XmlWriter/EnumXmlWriter.scala | 14 +- .../scala/codegen/XmlWriter/XmlWriter.scala | 20 +- 15 files changed, 233 insertions(+), 233 deletions(-) diff --git a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala index 93a1e63ce..08c6de075 100644 --- a/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala +++ b/compiler/lib/src/main/scala/analysis/CheckSemantics/CheckExprTypes.scala @@ -255,7 +255,7 @@ object CheckExprTypes extends UseAnalyzer { override def structTypeMemberAnnotatedNode( a: Analysis, aNode: Ast.Annotated[AstNode[Ast.StructTypeMember]] - ): Result = { + ) = { val (_, node, _) = aNode val data = node.data for { diff --git a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala index d6a0da08d..0a475e073 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/PortInstance.scala @@ -6,7 +6,7 @@ import fpp.compiler.util._ /** An FPP port instance */ sealed trait PortInstance { - override def toString: String = getUnqualifiedName.toString + override def toString = getUnqualifiedName.toString /** Gets the size of the port array */ def getArraySize: Int = 1 @@ -108,7 +108,7 @@ object PortInstance { ty: Type, ) extends PortInstance { - override def getDirection: Option[Direction] = kind match { + override def getDirection = kind match { case General.Kind.Output => Some(Direction.Output) case _ => Some(Direction.Input) } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala index 3d890f33d..a05e0289f 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Type.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Type.scala @@ -195,7 +195,7 @@ object Type { default: Option[Value.EnumConstant] = None ) extends Type { override def getDefaultValue: Option[Value.EnumConstant] = default - override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) + override def getDefNodeId = Some(node._2.id) override def isConvertibleToNumeric = true override def isPromotableToArray = true override def toString = "enum " ++ node._2.data.name @@ -215,7 +215,7 @@ object Type { formats: Struct.Formats = Map(), ) extends Type { override def getDefaultValue: Option[Value.Struct] = default - override def getDefNodeId: Some[AstNode.Id] = Some(node._2.id) + override def getDefNodeId = Some(node._2.id) override def hasNumericMembers = anonStruct.hasNumericMembers override def toString = "struct " ++ node._2.data.name } diff --git a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala index 052a04492..69be99b35 100644 --- a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala +++ b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala @@ -14,7 +14,7 @@ trait AstStateVisitor extends AstVisitor { type Result = Result.Result[State] /** Default state transformation */ - def default(s: State): Out = Right(s) + override def default(s: In) = Right(s) /** Visit a list in sequence, threading state */ def visitList[T]( diff --git a/compiler/lib/src/main/scala/codegen/AstWriter.scala b/compiler/lib/src/main/scala/codegen/AstWriter.scala index 79614752f..c7843c101 100644 --- a/compiler/lib/src/main/scala/codegen/AstWriter.scala +++ b/compiler/lib/src/main/scala/codegen/AstWriter.scala @@ -13,7 +13,7 @@ object AstWriter extends AstVisitor with LineUtils { def transUnit(tu: Ast.TransUnit): Out = transUnit((), tu) override def defAbsTypeAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] ) = { val (_, node, _) = aNode @@ -21,7 +21,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defArrayAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]] ) = { val (_, node, _) = aNode @@ -37,7 +37,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defComponentAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val (_, node, _) = aNode @@ -52,7 +52,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defComponentInstanceAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] ) = { val (_, node, _) = aNode @@ -72,7 +72,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defConstantAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] ) = { val (_, node, _) = aNode @@ -82,7 +82,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defEnumAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] ) = { val (_, node, _) = aNode @@ -96,7 +96,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defModuleAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (_, node, _) = aNode @@ -106,7 +106,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defPortAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]] ) = { val (_, node, _) = aNode @@ -120,7 +120,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defStructAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] ) = { val (_, node, _) = aNode @@ -134,7 +134,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def defTopologyAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] ) = { val (_, node, _) = aNode @@ -143,11 +143,11 @@ object AstWriter extends AstVisitor with LineUtils { (ident(data.name) ++ data.members.map(topologyMember).flatten).map(indentIn) } - override def default(in: Unit) = + override def default(in: In) = throw new InternalError("AstWriter: Visitor not implemented") override def exprArrayNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprArray ) = @@ -155,7 +155,7 @@ object AstWriter extends AstVisitor with LineUtils { e.elts.map(exprNode).flatten.map(indentIn) override def exprBinopNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprBinop ) = @@ -163,7 +163,7 @@ object AstWriter extends AstVisitor with LineUtils { (exprNode(e.e1) ++ binop(e.op) ++ exprNode(e.e2)).map(indentIn) override def exprDotNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprDot ) = @@ -171,14 +171,14 @@ object AstWriter extends AstVisitor with LineUtils { (exprNode(e.e) ++ ident(e.id.data)).map(indentIn) override def exprIdentNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprIdent ) = ident(e.value) override def exprLiteralBoolNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool ) = { @@ -190,28 +190,28 @@ object AstWriter extends AstVisitor with LineUtils { } override def exprLiteralFloatNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat ) = lines("literal float " ++ e.value) override def exprLiteralIntNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt ) = lines("literal int " ++ e.value) override def exprLiteralStringNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString ) = addPrefix("literal string", string) (e.value) override def exprParenNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprParen ) = @@ -219,7 +219,7 @@ object AstWriter extends AstVisitor with LineUtils { exprNode(e.e).map(indentIn) override def exprStructNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprStruct ) = @@ -227,7 +227,7 @@ object AstWriter extends AstVisitor with LineUtils { e.members.map(applyToData(structMember)).flatten.map(indentIn) override def exprUnopNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprUnop ) = @@ -235,7 +235,7 @@ object AstWriter extends AstVisitor with LineUtils { (unop(e.op) ++ exprNode(e.e)).map(indentIn) override def specCommandAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] ) = { val (_, node, _) = aNode @@ -252,7 +252,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specCompInstanceAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] ) = { val (_, node, _) = aNode @@ -264,7 +264,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specConnectionGraphAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] ) = { def direct(g: Ast.SpecConnectionGraph.Direct) = { @@ -297,7 +297,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specEventAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] ) = { val (_, node, _) = aNode @@ -314,16 +314,16 @@ object AstWriter extends AstVisitor with LineUtils { } override def specIncludeAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecInclude]] - ) = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec include") ++ fileString(data.file.data).map(indentIn) } override def specInternalPortAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] ) = { val (_, node, _) = aNode @@ -338,7 +338,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specLocAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecLoc]] ) = { val (_, node, _) = aNode @@ -353,7 +353,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specParamAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] ) = { val (_, node, _) = aNode @@ -370,7 +370,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specPortInstanceAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] ) = { val (_, node, _) = aNode @@ -398,7 +398,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specPortMatchingAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] ) = { val (_, node, _) = aNode @@ -411,7 +411,7 @@ object AstWriter extends AstVisitor with LineUtils { } override def specTlmChannelAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] ) = { val (_, node, _) = aNode @@ -442,42 +442,42 @@ object AstWriter extends AstVisitor with LineUtils { } override def specTopImportAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ) = { + ) = { val (_, node, _) = aNode val data = node.data lines("spec top import") ++ qualIdent(data.top.data).map(indentIn) } - override def transUnit(in: Unit, tu: Ast.TransUnit) = + override def transUnit(in: In, tu: Ast.TransUnit) = tu.members.map(tuMember).flatten override def typeNameBoolNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName] ) = lines("bool") override def typeNameFloatNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat ) = lines(tn.name.toString) override def typeNameIntNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt ) = lines(tn.name.toString) override def typeNameQualIdentNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent ) = qualIdent(tn.name.data) override def typeNameStringNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString ) = @@ -485,19 +485,19 @@ object AstWriter extends AstVisitor with LineUtils { private def addPrefixNoIndent[T]( s: String, - f: T => List[Line] - ): T => List[Line] = + f: T => Out + ): T => Out = (t: T) => Line.joinLists (Line.NoIndent) (lines(s)) (" ") (f(t)) private def addPrefix[T]( s: String, - f: T => List[Line] - ): T => List[Line] = + f: T => Out + ): T => Out = (t: T) => Line.joinLists (Line.Indent) (lines(s)) (" ") (f(t)) private def annotate( pre: List[String], - lines: List[Line], + lines: Out, post: List[String] ) = { def preLine(s: String) = line("@ " ++ s) @@ -507,7 +507,7 @@ object AstWriter extends AstVisitor with LineUtils { pre1 ++ lines ++ post1 } - private def annotateNode[T](f: T => List[Line]): Ast.Annotated[AstNode[T]] => List[Line] = + private def annotateNode[T](f: T => Out): Ast.Annotated[AstNode[T]] => Out = (ana: Ast.Annotated[AstNode[T]]) => { val (a1, node, a2) = ana annotate(a1, f(node.data), a2) @@ -531,7 +531,7 @@ object AstWriter extends AstVisitor with LineUtils { linesOpt(exprNode, dec.value) ).flatten.map(indentIn) - private def exprNode(node: AstNode[Ast.Expr]): List[Line] = + private def exprNode(node: AstNode[Ast.Expr]): Out = matchExprNode((), node) private def fileString(s: String) = lines("file " ++ s) @@ -563,12 +563,12 @@ object AstWriter extends AstVisitor with LineUtils { annotate(a1, l, a2) } - private def portInstanceIdentifier(pii: Ast.PortInstanceIdentifier): List[Line] = { + private def portInstanceIdentifier(pii: Ast.PortInstanceIdentifier): Out = { val qid = Ast.QualIdent.Qualified(pii.componentInstance, pii.portName) qualIdent(qid) } - private def qualIdent(qid: Ast.QualIdent): List[Line] = + private def qualIdent(qid: Ast.QualIdent): Out = lines("qual ident " ++ qualIdentString(qid)) private def qualIdentString(qid: Ast.QualIdent): String = diff --git a/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala b/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala index dfb044d09..46166ac93 100644 --- a/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala +++ b/compiler/lib/src/main/scala/codegen/ComputeGeneratedFiles.scala @@ -15,13 +15,13 @@ object ComputeGeneratedFiles { } yield xmlFiles ++ cppFiles - def getCppFiles(tul: List[Ast.TransUnit]): Either[Error,List[String]] = + def getCppFiles(tul: List[Ast.TransUnit]): Result.Result[List[String]] = for { s <- ComputeCppFiles.visitList(Map(), tul, ComputeCppFiles.transUnit) } yield s.toList.map(_._1) - def getXmlFiles(a: Analysis, tul: List[Ast.TransUnit]): Either[Error,List[String]] = + def getXmlFiles(a: Analysis, tul: List[Ast.TransUnit]): Result.Result[List[String]] = for { s <- ComputeXmlFiles.visitList( XmlWriterState(a), diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala index 874aec5b3..8f9555abe 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala @@ -38,10 +38,14 @@ object ConstantCppWriter { private object Visitor extends AstVisitor with LineUtils { - override def default(s: CppWriterState) = Nil + type In = CppWriterState + + type Out = List[CppDoc.Member] + + override def default(s: In) = Nil override def defConstantAnnotatedNode( - s: CppWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] ) = { val node = aNode._2 @@ -79,7 +83,7 @@ object ConstantCppWriter { } override def defModuleAnnotatedNode( - s: CppWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (_, node, _) = aNode @@ -94,7 +98,7 @@ object ConstantCppWriter { } override def defComponentAnnotatedNode( - s: CppWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val (_, node, _) = aNode @@ -103,7 +107,7 @@ object ConstantCppWriter { members } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = + override def transUnit(s: In, tu: Ast.TransUnit) = tu.members.flatMap(matchTuMember(s, _)) private def writeBooleanConstant(name: String, value: String) = @@ -140,10 +144,6 @@ object ConstantCppWriter { ) } - type In = CppWriterState - - type Out = List[CppDoc.Member] - } } diff --git a/compiler/lib/src/main/scala/codegen/FppWriter.scala b/compiler/lib/src/main/scala/codegen/FppWriter.scala index e3f091e1a..004ddcde7 100644 --- a/compiler/lib/src/main/scala/codegen/FppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/FppWriter.scala @@ -7,29 +7,33 @@ import scala.language.implicitConversions /** Write out FPP source */ object FppWriter extends AstVisitor with LineUtils { - private case class JoinOps(ls: List[Line]) { + type In = Unit + + type Out = List[Line] - def addSuffix(suffix: String): List[Line] = Line.addSuffix(ls, suffix) + private case class JoinOps(ls: Out) { - def join (sep: String) (ls1: List[Line]): List[Line] = + def addSuffix(suffix: String): Out = Line.addSuffix(ls, suffix) + + def join (sep: String) (ls1: Out): Out = Line.joinLists (Line.Indent) (ls) (sep) (ls1) - def joinNoIndent (sep: String) (ls1: List[Line]): List[Line] = + def joinNoIndent (sep: String) (ls1: Out): Out = Line.joinLists (Line.NoIndent) (ls) (sep) (ls1) - def joinWithBreak[T] (sep: String) (ls1: List[Line]): List[Line] = + def joinWithBreak[T] (sep: String) (ls1: Out): Out = (sep, ls1) match { case ("", Nil) => ls case _ => Line.addSuffix(ls, " \\") ++ Line.addPrefix(sep, ls1).map(indentIn) } - def joinOpt[T] (opt: Option[T]) (sep: String) (f: T => List[Line]): List[Line] = + def joinOpt[T] (opt: Option[T]) (sep: String) (f: T => Out): Out = opt match { case Some(t) => join (sep) (f(t)) case None => ls } - def joinOptWithBreak[T] (opt: Option[T]) (sep: String) (f: T => List[Line]): List[Line] = + def joinOptWithBreak[T] (opt: Option[T]) (sep: String) (f: T => Out): Out = opt match { case Some(t) => joinWithBreak (sep) (f(t)) case None => ls @@ -37,21 +41,21 @@ object FppWriter extends AstVisitor with LineUtils { } - private implicit def lift(ls: List[Line]): JoinOps = JoinOps(ls) + private implicit def lift(ls: Out): JoinOps = JoinOps(ls) - def componentMember(member: Ast.ComponentMember): List[Line] = { + def componentMember(member: Ast.ComponentMember): Out = { val (a1, _, a2) = member.node val l = matchComponentMember((), member) annotate(a1, l, a2) } - def moduleMember(member: Ast.ModuleMember): List[Line] = { + def moduleMember(member: Ast.ModuleMember): Out = { val (a1, _, a2) = member.node val l = matchModuleMember((), member) annotate(a1, l, a2) } - def topologyMember(member: Ast.TopologyMember): List[Line] = { + def topologyMember(member: Ast.TopologyMember): Out = { val (a1, _, a2) = member.node val l = matchTopologyMember((), member) annotate(a1, l, a2) @@ -59,24 +63,24 @@ object FppWriter extends AstVisitor with LineUtils { def transUnit(tu: Ast.TransUnit): Out = transUnit((), tu) - def tuMember(tum: Ast.TUMember): List[Line] = moduleMember(tum) + def tuMember(tum: Ast.TUMember): Out = moduleMember(tum) - def tuMemberList(tuml: List[Ast.TUMember]): List[Line] = + def tuMemberList(tuml: List[Ast.TUMember]): Out = Line.blankSeparated (tuMember) (tuml) override def defAbsTypeAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"type ${ident(data.name)}") } override def defArrayAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"array ${ident(data.name)} = ["). @@ -87,9 +91,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def defComponentAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -101,7 +105,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defComponentInstanceAnnotatedNode( in: In, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ): List[Line] = { + ) = { def initSpecs(list: List[Ast.Annotated[AstNode[Ast.SpecInit]]]) = addBracesIfNonempty(list.flatMap(annotateNode(specInit))) val (_, node, _) = aNode @@ -118,18 +122,18 @@ object FppWriter extends AstVisitor with LineUtils { } override def defConstantAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"constant ${ident(data.name)}").join (" = ") (exprNode(data.value)) } override def defEnumAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"enum ${ident(data.name)}"). @@ -140,9 +144,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def defModuleAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data List(line(s"module ${ident(data.name)} {"), Line.blank) ++ @@ -151,9 +155,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def defPortAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"port ${ident(data.name)}"). @@ -162,9 +166,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def defStructAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"struct ${ident(data.name)}"). @@ -177,7 +181,7 @@ object FppWriter extends AstVisitor with LineUtils { override def defTopologyAnnotatedNode( in: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data List(line(s"topology ${ident(data.name)} {"), Line.blank) ++ @@ -185,80 +189,80 @@ object FppWriter extends AstVisitor with LineUtils { List(Line.blank, line("}")) } - override def default(in: Unit) = + override def default(in: In) = throw new InternalError("FppWriter: Visitor not implemented") override def exprArrayNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprArray - ): List[Line] = + ) = (line("[") :: e.elts.flatMap(exprNode).map(indentIn)) :+ line("]") override def exprBinopNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprBinop - ): List[Line] = exprNode(e.e1).join (binop(e.op)) (exprNode(e.e2)) + ) = exprNode(e.e1).join (binop(e.op)) (exprNode(e.e2)) override def exprDotNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprDot - ): List[Line] = exprNode(e.e).join (".") (lines(e.id.data)) + ) = exprNode(e.e).join (".") (lines(e.id.data)) override def exprIdentNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprIdent - ): List[Line] = lines(e.value) + ) = lines(e.value) override def exprLiteralBoolNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralBool - ): List[Line] = lines(e.value.toString) + ) = lines(e.value.toString) override def exprLiteralFloatNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralFloat - ): List[Line] = lines(e.value) + ) = lines(e.value) override def exprLiteralIntNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt - ): List[Line] = lines(e.value) + ) = lines(e.value) override def exprLiteralStringNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString - ): List[Line] = string(e.value) + ) = string(e.value) override def exprParenNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprParen - ): List[Line] = Line.addPrefixAndSuffix("(", exprNode(e.e), ")") + ) = Line.addPrefixAndSuffix("(", exprNode(e.e), ")") override def exprStructNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprStruct - ): List[Line] = addBraces(e.members.flatMap(applyToData(structMember))) + ) = addBraces(e.members.flatMap(applyToData(structMember))) override def exprUnopNode( - in: Unit, + in: In, node: AstNode[Ast.Expr], e: Ast.ExprUnop - ): List[Line] = lines(unop(e.op)).join ("") (exprNode(e.e)) + ) = lines(unop(e.op)).join ("") (exprNode(e.e)) override def specCommandAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecCommand]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -270,9 +274,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specCompInstanceAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val visibility = data.visibility match { @@ -284,9 +288,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specConnectionGraphAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]] - ): Out = { + ) = { val (_, node, _) = aNode def direct(scg: Ast.SpecConnectionGraph.Direct) = lines(s"connections ${ident(scg.name)}"). @@ -309,9 +313,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specEventAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val severity = data.severity.toString @@ -324,18 +328,18 @@ object FppWriter extends AstVisitor with LineUtils { } override def specIncludeAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecInclude]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines("include").join (" ") (string(data.file.data)) } override def specInternalPortAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecInternalPort]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"internal port ${ident(data.name)}"). @@ -345,9 +349,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specLocAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecLoc]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val kind = data.kind.toString @@ -357,9 +361,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specParamAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecParam]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data lines(s"param ${ident(data.name)}"). @@ -371,9 +375,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specPortInstanceAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]] - ): Out = { + ) = { val (_, node, _) = aNode def general(i: Ast.SpecPortInstance.General) = { val kind = i.kind.toString @@ -399,9 +403,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specPortMatchingAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecPortMatching]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val port1 = data.port1.data @@ -410,9 +414,9 @@ object FppWriter extends AstVisitor with LineUtils { } override def specTlmChannelAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data def update(u: Ast.SpecTlmChannel.Update) = lines(u.toString) @@ -436,52 +440,52 @@ object FppWriter extends AstVisitor with LineUtils { } override def specTopImportAnnotatedNode( - in: Unit, + in: In, aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data Line.addPrefix("import ", qualIdent(data.top.data)) } override def transUnit( - in: Unit, + in: In, tu: Ast.TransUnit - ): List[Line] = tuMemberList(tu.members) + ) = tuMemberList(tu.members) override def typeNameBoolNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName] - ): List[Line] = lines("bool") + ) = lines("bool") override def typeNameFloatNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameFloat - ): List[Line] = lines(tn.name.toString) + ) = lines(tn.name.toString) override def typeNameIntNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameInt - ): List[Line] = lines(tn.name.toString) + ) = lines(tn.name.toString) override def typeNameQualIdentNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent - ): List[Line] = qualIdent(tn.name.data) + ) = qualIdent(tn.name.data) override def typeNameStringNode( - in: Unit, + in: In, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString - ): List[Line] = lines("string").joinOpt (tn.size) (" size ") (exprNode) + ) = lines("string").joinOpt (tn.size) (" size ") (exprNode) - private def addBraces(ls: List[Line]): List[Line] = + private def addBraces(ls: Out): Out = line("{") :: (ls.map(indentIn) :+ line("}")) - private def addBracesIfNonempty(ls: List[Line]): List[Line] = + private def addBracesIfNonempty(ls: Out): Out = ls match { case Nil => Nil case _ => addBraces(ls) @@ -489,7 +493,7 @@ object FppWriter extends AstVisitor with LineUtils { private def annotate( pre: List[String], - lines: List[Line], + lines: Out, post: List[String] ) = { val pre1 = pre.map((s: String) => line("@ " ++ s)) @@ -497,8 +501,8 @@ object FppWriter extends AstVisitor with LineUtils { (pre1 ++ lines).join (" ") (post1) } - private def annotateNode[T](f: T => List[Line]): - Ast.Annotated[AstNode[T]] => List[Line] = + private def annotateNode[T](f: T => Out): + Ast.Annotated[AstNode[T]] => Out = (aNode: Ast.Annotated[AstNode[T]]) => { val (a1, node, a2) = aNode annotate(a1, f(node.data), a2) @@ -515,7 +519,7 @@ object FppWriter extends AstVisitor with LineUtils { private def defEnumConstant(dec: Ast.DefEnumConstant) = lines(ident(dec.name)).joinOpt (dec.value) (" = ") (exprNode) - private def exprNode(node: AstNode[Ast.Expr]): List[Line] = + private def exprNode(node: AstNode[Ast.Expr]): Out = matchExprNode((), node) private def ident(id: Ast.Ident) = @@ -539,7 +543,7 @@ object FppWriter extends AstVisitor with LineUtils { lines(")") } - private def qualIdent(qid: Ast.QualIdent): List[Line] = + private def qualIdent(qid: Ast.QualIdent): Out = lines(qualIdentString(qid)) private def qualIdentString(qid: Ast.QualIdent): String = @@ -586,10 +590,6 @@ object FppWriter extends AstVisitor with LineUtils { private def unop(op: Ast.Unop) = op.toString - type In = Unit - - type Out = List[Line] - val keywords: Set[String] = Set( "F32", "F64", diff --git a/compiler/lib/src/main/scala/codegen/Indentation.scala b/compiler/lib/src/main/scala/codegen/Indentation.scala index 851c87571..b97f37713 100644 --- a/compiler/lib/src/main/scala/codegen/Indentation.scala +++ b/compiler/lib/src/main/scala/codegen/Indentation.scala @@ -6,7 +6,7 @@ package fpp.compiler.codegen case class Indentation(n: Int) { /** Format the indentation as a string of spaces */ - override def toString: String = { + override def toString = { def helper(n: Int, s: String): String = if (n < 1) s else helper(n - 1, " " ++ s) helper(n, "") diff --git a/compiler/lib/src/main/scala/codegen/Line.scala b/compiler/lib/src/main/scala/codegen/Line.scala index a2df19623..aa5c68a89 100644 --- a/compiler/lib/src/main/scala/codegen/Line.scala +++ b/compiler/lib/src/main/scala/codegen/Line.scala @@ -99,7 +99,7 @@ object Line { case class Line(string: String = "", indent: Indentation = Indentation(0)) { /** Convert the line to a formatted string */ - override def toString: String = string match { + override def toString = string match { case "" => "" case _ => indent.toString ++ string } diff --git a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala index 6863c3417..99f2c74c2 100644 --- a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala @@ -8,6 +8,10 @@ import scala.language.implicitConversions /** Writes out the locations of definitions */ object LocateDefsFppWriter extends AstVisitor with LineUtils { + type In = State + + type Out = List[Line] + case class State( /** The base directory for constructing location specifiers */ val baseDir: Option[String], @@ -15,30 +19,30 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { val scopeNameList: List[Name.Unqualified] = Nil ) - override def default(s: State) = Nil + override def default(s: In) = Nil override def defAbsTypeAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) } override def defArrayAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) } override def defComponentAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data val s1 = s.copy(scopeNameList = data.name :: s.scopeNameList) @@ -47,36 +51,36 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defComponentInstanceAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.ComponentInstance, data.name, node) } override def defConstantAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Constant, data.name, node) } override def defEnumAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) } override def defModuleAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val Ast.DefModule(name, members) = node.data val s1 = s.copy(scopeNameList = name :: s.scopeNameList) @@ -84,41 +88,41 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defPortAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Port, data.name, node) } override def defStructAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Type, data.name, node) } override def defTopologyAnnotatedNode( - s: State, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] - ): List[Line] = { + ) = { val (_, node, _) = aNode val data = node.data writeSpecLoc(s, Ast.SpecLoc.Topology, data.name, node) } - override def transUnit(s: State, tu: Ast.TransUnit) = + override def transUnit(s: In, tu: Ast.TransUnit) = tu.members.flatMap(matchModuleMember(s, _)) private def writeSpecLoc[T]( - s: State, + s: In, kind: Ast.SpecLoc.Kind, name: String, node: AstNode[T] - ): List[Line] = { + ): Out = { val loc = Locations.get(node.id).tuLocation loc.file match { case File.Path(path) => { @@ -139,8 +143,4 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } } - type In = State - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala index 1c33481ea..4e4b61e28 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala @@ -7,9 +7,13 @@ import fpp.compiler.util._ /** Write out F Prime XML for array definitions */ object ArrayXmlWriter extends AstVisitor with LineUtils { - override def default(s: XmlWriterState) = Nil + type In = XmlWriterState + + type Out = List[Line] + + override def default(s: In) = Nil - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val node = aNode._2 val data = node.data val tags = { @@ -70,17 +74,13 @@ object ArrayXmlWriter extends AstVisitor with LineUtils { /** Writes the default value corresponding to an array value */ def writeDefaultValue( - s: XmlWriterState, + s: In, arrayValue: Value.Array - ): List[Line] = { + ): Out = { val tags = XmlTags.tags("value") val elements = arrayValue.anonArray.elements val values = elements.map(ValueXmlWriter.getValue(s, _)) values.map(XmlTags.taggedString(tags)(_)).map(line) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala index d77c09dc5..0e26b2712 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala @@ -12,7 +12,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] override def defComponentAnnotatedNode( - s: XmlWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val symbol = Symbol.Component(aNode) @@ -37,9 +37,9 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines ("component", pairs) (body.map(indentIn)) } - override def default(s: XmlWriterState) = Nil + override def default(s: In) = Nil - private def writeCommands(s: XmlWriterState, c: Component) = { + private def writeCommands(s: In, c: Component) = { import Command._ def writeNonParamCommand(opcode: Opcode, nonParam: NonParam) = { import NonParam._ @@ -85,7 +85,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("commands") (commands.map(indentIn)) } - private def writeEvents(s: XmlWriterState, c: Component) = { + private def writeEvents(s: In, c: Component) = { import Event._ def writeEvent(id: Id, event: Event) = { val data = event.aNode._2.data @@ -131,12 +131,12 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("events") (events.map(indentIn)) } - private def writeImports(s: XmlWriterState, c: Component) = { + private def writeImports(s: In, c: Component) = { val Right(a) = UsedSymbols.defComponentAnnotatedNode(s.a, c.aNode) s.writeImportDirectives(a.usedSymbolSet) } - private def writeInternalInterfaces(s: XmlWriterState, c: Component) = { + private def writeInternalInterfaces(s: In, c: Component) = { def writeInternalPort(name: String, internal: PortInstance.Internal) = { import PortInstance.Internal._ val data = internal.aNode._2.data @@ -165,7 +165,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("internal_interfaces") (ports.map(indentIn)) } - private def writeParams(s: XmlWriterState, c: Component) = { + private def writeParams(s: In, c: Component) = { import Param._ def writeParam(id: Id, param: Param) = { val data = param.aNode._2.data @@ -190,7 +190,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("parameters") (params.map(indentIn)) } - private def writePorts(s: XmlWriterState, c: Component) = { + private def writePorts(s: In, c: Component) = { def writeGeneralPort(name: String, general: PortInstance.General) = { import PortInstance.General._ def writeDataType(ty: PortInstance.Type) = ty match { @@ -268,7 +268,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("ports") (ports.map(indentIn)) } - private def writeTlmChannels(s: XmlWriterState, c: Component) = { + private def writeTlmChannels(s: In, c: Component) = { import TlmChannel._ def writeTlmChannel(id: Id, tlmChannel: TlmChannel) = { val data = tlmChannel.aNode._2.data diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala index 113a4e95a..64ac94728 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala @@ -7,9 +7,13 @@ import fpp.compiler.util._ /** Write out F Prime XML for enum definitions */ object EnumXmlWriter extends AstVisitor with LineUtils { - override def default(s: XmlWriterState) = Nil + type In = XmlWriterState + + type Out = List[Line] + + override def default(s: In) = Nil - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val node = aNode._2 val data = node.data val enumType @ Type.Enum(_, _, _) = s.a.typeMap(node.id) @@ -33,7 +37,7 @@ object EnumXmlWriter extends AstVisitor with LineUtils { } def defEnumConstantAnnotatedNode( - s: XmlWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]] ): Line = { val node = aNode._2 @@ -50,8 +54,4 @@ object EnumXmlWriter extends AstVisitor with LineUtils { line(XmlTags.openCloseTag("item", pairs)) } - type In = XmlWriterState - - type Out = List[Line] - } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala index 935820612..5c960da83 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala @@ -9,7 +9,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { type State = XmlWriterState - override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Array(aNode)) @@ -18,7 +18,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { + override def defComponentAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Component(aNode)) @@ -31,7 +31,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { yield s } - override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Enum(aNode)) @@ -41,15 +41,15 @@ object XmlWriter extends AstStateVisitor with LineUtils { } override def defModuleAnnotatedNode( - s: XmlWriterState, + s: In, aNode: Ast.Annotated[AstNode[Ast.DefModule]] - ): Result = { + ) = { val (_, node, _) = aNode val data = node.data visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Port(aNode)) @@ -58,7 +58,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data @@ -71,7 +71,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { } yield s } - override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { + override def defTopologyAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Topology(aNode)) @@ -80,7 +80,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def transUnit(s: XmlWriterState, tu: Ast.TransUnit) = + override def transUnit(s: In, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) private def writeXmlHeader(fileName: String) = lines( @@ -93,7 +93,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { |""" ) - private def writeXmlFile(s: XmlWriterState, fileName: String, lines: List[Line]) = { + private def writeXmlFile(s: In, fileName: String, lines: List[Line]) = { val path = java.nio.file.Paths.get(s.dir, fileName) val file = File.Path(path) val headerLines = writeXmlHeader(fileName) From 132207ca48b0ac64e9c390a9ce1ea44c55770858 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Mon, 16 May 2022 13:43:29 -0700 Subject: [PATCH 09/14] Minor changes per @bocchino's review --- .../Analyzers/TypeExpressionAnalyzer.scala | 2 +- .../scala/analysis/Semantics/TypeVisitor.scala | 9 ++++----- .../src/main/scala/analysis/Semantics/Value.scala | 14 +++++++------- .../scala/analysis/Semantics/ValueVisitor.scala | 8 ++++---- 4 files changed, 16 insertions(+), 17 deletions(-) diff --git a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala index 9b718fb08..b32a59aa3 100644 --- a/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala +++ b/compiler/lib/src/main/scala/analysis/Analyzers/TypeExpressionAnalyzer.scala @@ -42,7 +42,7 @@ trait TypeExpressionAnalyzer } yield a } - def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Out = matchTypeNameNode(a, node) + def typeNameNode(a: Analysis, node: AstNode[Ast.TypeName]): Result = matchTypeNameNode(a, node) override def typeNameStringNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameString) = opt(exprNode)(a, tn.size) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala index 770542f58..957cd932c 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/TypeVisitor.scala @@ -3,6 +3,10 @@ package fpp.compiler.analysis /** Visit a type */ trait TypeVisitor { + type In + + type Out + def absType(in: In, t: Type.AbsType): Out = default(in, t) def anonArray(in: In, t: Type.AnonArray): Out = default(in, t) @@ -43,9 +47,4 @@ trait TypeVisitor { case t : Type.String => string(in, t) case t : Type.Struct => struct(in, t) } - - type In - - type Out - } diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala index a11629a4e..bee9706dc 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Value.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Value.scala @@ -35,7 +35,7 @@ sealed trait Value { } /** Generic binary operation */ - protected[analysis] def binop(op: Value.Binop)(v: Value): Option[Value] = None + private[analysis] def binop(op: Value.Binop)(v: Value): Option[Value] = None /** Get the type of the value */ def getType: Type @@ -108,7 +108,7 @@ object Value { extends Value { - override protected[analysis] def binop(op: Binop)(v: Value) = v match { + override private[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result1 = op.intOp(value, value1) val result2 = if (kind1 == kind) PrimitiveInt(result1, kind) else Integer(result1) @@ -169,7 +169,7 @@ object Value { (value >= - (u64Bound / 2) && value < u64Bound) } - override protected[analysis] def binop(op: Binop)(v: Value) = v match { + override private[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result = op.intOp(value, value1) Some(Integer(result)) @@ -205,7 +205,7 @@ object Value { /** Floating-point values */ case class Float(value: Double, kind: Type.Float.Kind) extends Value { - override protected[analysis] def binop(op: Binop)(v: Value) = v match { + override private[analysis] def binop(op: Binop)(v: Value) = v match { case PrimitiveInt(value1, kind1) => { val result = op.doubleOp(value, value1.toDouble) Some(Float(result.toFloat, Type.Float.F64)) @@ -357,7 +357,7 @@ object Value { /** Enum constant values */ case class EnumConstant(value: (Name.Unqualified, BigInt), t: Type.Enum) extends Value { - override protected[analysis] def binop(op: Binop)(v: Value) = convertToRepType.binop(op)(v) + override private[analysis] def binop(op: Binop)(v: Value) = convertToRepType.binop(op)(v) /** Convert the enum to the representation type */ def convertToRepType: PrimitiveInt = PrimitiveInt(value._2, t.repType.kind) @@ -468,14 +468,14 @@ object Value { } /** Binary operations */ - protected[analysis] case class Binop( + private[analysis] case class Binop( /** The integer operation */ intOp: Binop.Op[BigInt], /** The double-precision floating point operation */ doubleOp: Binop.Op[Double] ) - protected[analysis] object Binop { + private[analysis] object Binop { /** A binary operation */ type Op[T] = (T, T) => T diff --git a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala index 861c2dc67..6647fd729 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/ValueVisitor.scala @@ -3,6 +3,10 @@ package fpp.compiler.analysis /** Visit a Value */ trait ValueVisitor { + type In + + type Out + def absType(in: In, v: Value.AbsType): Out = default(in, v) def anonArray(in: In, v: Value.AnonArray): Out = default(in, v) @@ -45,8 +49,4 @@ trait ValueVisitor { } } - type In - - type Out - } From 0563f52b003dd35ff883eb4fe796938df13392a9 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Mon, 16 May 2022 14:38:48 -0700 Subject: [PATCH 10/14] Use Result.Result[T] instead of Either[Error,T] --- .../scala/analysis/Semantics/Component.scala | 2 +- .../codegen/CppWriter/ConstantCppWriter.scala | 2 +- .../main/scala/codegen/CppWriter/CppWriter.scala | 16 ++++++++-------- .../XmlFppWriter/ComponentXmlFppWriter.scala | 6 +++--- .../codegen/XmlFppWriter/XmlFppWriter.scala | 2 +- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala index 70c98b0fd..98f0e20a1 100644 --- a/compiler/lib/src/main/scala/analysis/Semantics/Component.scala +++ b/compiler/lib/src/main/scala/analysis/Semantics/Component.scala @@ -341,7 +341,7 @@ case class Component( } /** Complete a component definition */ - def complete: Either[Error,Component] = for { + def complete: Result.Result[Component] = for { c <- this.constructPortMatchingList _ <- c.checkValidity } yield c diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala index 8f9555abe..e6a054ab9 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala @@ -9,7 +9,7 @@ import fpp.compiler.util._ object ConstantCppWriter { /** Writes out constant hpp and cpp */ - def write(s: CppWriterState, tuList: List[Ast.TransUnit]): Either[Error,Any] = + def write(s: CppWriterState, tuList: List[Ast.TransUnit]): Result.Result[Any] = tuList.flatMap(Visitor.transUnit(s, _)) match { case Nil => Right(()) case constantMembers => diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala index a7fafc42e..685c38ceb 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/CppWriter.scala @@ -10,7 +10,7 @@ object CppWriter extends AstStateVisitor with LineUtils { type State = CppWriterState override def defModuleAnnotatedNode( - s: CppWriterState, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val node = aNode._2 @@ -19,7 +19,7 @@ object CppWriter extends AstStateVisitor with LineUtils { } override def defTopologyAnnotatedNode( - s: CppWriterState, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] ) = { val node = aNode._2 @@ -28,10 +28,10 @@ object CppWriter extends AstStateVisitor with LineUtils { writeCppDoc(s, cppDoc) } - override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) - def tuList(s: CppWriterState, tul: List[Ast.TransUnit]): Either[Error,Unit] = + def tuList(s: State, tul: List[Ast.TransUnit]): Result.Result[Unit] = for { _ <- ConstantCppWriter.write(s, tul) _ <- visitList(s, tul, transUnit) @@ -74,25 +74,25 @@ object CppWriter extends AstStateVisitor with LineUtils { List(namespaceMember(head, wrapInNamespaces(tail, members))) } - def writeCppDoc(s: CppWriterState, cppDoc: CppDoc): Either[Error,CppWriterState] = + def writeCppDoc(s: State, cppDoc: CppDoc): Result.Result[State] = for { _ <- writeHppFile(s, cppDoc) _ <- writeCppFile(s, cppDoc) } yield s - private def writeCppFile(s: CppWriterState, cppDoc: CppDoc) = { + private def writeCppFile(s: State, cppDoc: CppDoc) = { val lines = CppDocCppWriter.visitCppDoc(cppDoc) writeLinesToFile(s, cppDoc.cppFileName, lines) } - private def writeHppFile(s: CppWriterState, cppDoc: CppDoc) = { + private def writeHppFile(s: State, cppDoc: CppDoc) = { val lines = CppDocHppWriter.visitCppDoc(cppDoc) writeLinesToFile(s, cppDoc.hppFile.name, lines) } private def writeLinesToFile( - s: CppWriterState, + s: State, fileName: String, lines: List[Line] ) = { diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala index 5961ce8e0..9402ff5be 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/ComponentXmlFppWriter.scala @@ -70,7 +70,7 @@ object ComponentXmlFppWriter extends LineUtils { yield List(node) /** Generates a list of members */ - final def generateMembers(file: XmlFppWriter.File, node: scala.xml.Node): Either[Error,List[Ast.ComponentMember]] = + final def generateMembers(file: XmlFppWriter.File, node: scala.xml.Node): Result.Result[List[Ast.ComponentMember]] = generateMemberNodes(file, node) match { case Left(error) => Left(error) case Right(aNodes) => Right(aNodes.map(Ast.ComponentMember(_))) @@ -151,7 +151,7 @@ object ComponentXmlFppWriter extends LineUtils { val xmlName = "port" - def general(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Either[Error,Ast.SpecPortInstance.General] = { + def general(file: XmlFppWriter.File, xmlNode: scala.xml.Node): Result.Result[Ast.SpecPortInstance.General] = { import Ast.SpecPortInstance._ for { xmlKind <- file.getAttribute(xmlNode, "kind") @@ -179,7 +179,7 @@ object ComponentXmlFppWriter extends LineUtils { } } - def special(file: XmlFppWriter.File, xmlNode: scala.xml.Node, role: String): Either[Error,Ast.SpecPortInstance.Special] = { + def special(file: XmlFppWriter.File, xmlNode: scala.xml.Node, role: String): Result.Result[Ast.SpecPortInstance.Special] = { import Ast.SpecPortInstance._ for { kind <- role match { diff --git a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala index 0a12b4cfb..69f041184 100644 --- a/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlFppWriter/XmlFppWriter.scala @@ -175,7 +175,7 @@ object XmlFppWriter extends LineUtils { node.attribute(name).map(_.toList.head.toString) /** Writes a file list */ - def writeFileList(fileList: List[File]): Either[Error,List[Line]] = { + def writeFileList(fileList: List[File]): Result.Result[List[Line]] = { for (files <- Result.map(fileList, (file: File) => file.write)) yield Line.blankSeparated (identity[List[Line]]) (files) } From 84c7698a8a1dbcf6e35dbbf85c830b5738421181 Mon Sep 17 00:00:00 2001 From: bocchino Date: Tue, 17 May 2022 11:29:05 -0700 Subject: [PATCH 11/14] Revert changes to parameter types --- .../src/main/scala/ast/AstStateVisitor.scala | 2 +- .../codegen/CppWriter/ConstantCppWriter.scala | 10 +++---- .../scala/codegen/LocateDefsFppWriter.scala | 26 +++++++++---------- .../codegen/XmlWriter/ArrayXmlWriter.scala | 6 ++--- .../XmlWriter/ComponentXmlWriter.scala | 18 ++++++------- .../codegen/XmlWriter/EnumXmlWriter.scala | 6 ++--- .../codegen/XmlWriter/PortXmlWriter.scala | 4 +-- .../codegen/XmlWriter/StructXmlWriter.scala | 6 ++--- .../codegen/XmlWriter/TopologyXmlWriter.scala | 10 +++---- .../codegen/XmlWriter/TypeXmlWriter.scala | 18 ++++++------- .../codegen/XmlWriter/ValueXmlWriter.scala | 20 +++++++------- .../scala/codegen/XmlWriter/XmlWriter.scala | 18 ++++++------- .../scala/transform/ResolveSpecInclude.scala | 8 +++--- 13 files changed, 76 insertions(+), 76 deletions(-) diff --git a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala index 69be99b35..23bd3eca3 100644 --- a/compiler/lib/src/main/scala/ast/AstStateVisitor.scala +++ b/compiler/lib/src/main/scala/ast/AstStateVisitor.scala @@ -14,7 +14,7 @@ trait AstStateVisitor extends AstVisitor { type Result = Result.Result[State] /** Default state transformation */ - override def default(s: In) = Right(s) + override def default(s: State) = Right(s) /** Visit a list in sequence, threading state */ def visitList[T]( diff --git a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala index e6a054ab9..824d321fb 100644 --- a/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/CppWriter/ConstantCppWriter.scala @@ -42,10 +42,10 @@ object ConstantCppWriter { type Out = List[CppDoc.Member] - override def default(s: In) = Nil + override def default(s: CppWriterState) = Nil override def defConstantAnnotatedNode( - s: In, + s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] ) = { val node = aNode._2 @@ -83,7 +83,7 @@ object ConstantCppWriter { } override def defModuleAnnotatedNode( - s: In, + s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (_, node, _) = aNode @@ -98,7 +98,7 @@ object ConstantCppWriter { } override def defComponentAnnotatedNode( - s: In, + s: CppWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val (_, node, _) = aNode @@ -107,7 +107,7 @@ object ConstantCppWriter { members } - override def transUnit(s: In, tu: Ast.TransUnit) = + override def transUnit(s: CppWriterState, tu: Ast.TransUnit) = tu.members.flatMap(matchTuMember(s, _)) private def writeBooleanConstant(name: String, value: String) = diff --git a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala index 99f2c74c2..4b8b3b67c 100644 --- a/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala +++ b/compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala @@ -19,10 +19,10 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { val scopeNameList: List[Name.Unqualified] = Nil ) - override def default(s: In) = Nil + override def default(s: State) = Nil override def defAbsTypeAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefAbsType]] ) = { val (_, node, _) = aNode @@ -31,7 +31,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defArrayAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefArray]] ) = { val (_, node, _) = aNode @@ -40,7 +40,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defComponentAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val (_, node, _) = aNode @@ -51,7 +51,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defComponentInstanceAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]] ) = { val (_, node, _) = aNode @@ -60,7 +60,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defConstantAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefConstant]] ) = { val (_, node, _) = aNode @@ -69,7 +69,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defEnumAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefEnum]] ) = { val (_, node, _) = aNode @@ -78,7 +78,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defModuleAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (_, node, _) = aNode @@ -88,7 +88,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defPortAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefPort]] ) = { val (_, node, _) = aNode @@ -97,7 +97,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defStructAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefStruct]] ) = { val (_, node, _) = aNode @@ -106,7 +106,7 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { } override def defTopologyAnnotatedNode( - s: In, + s: State, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] ) = { val (_, node, _) = aNode @@ -114,11 +114,11 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils { writeSpecLoc(s, Ast.SpecLoc.Topology, data.name, node) } - override def transUnit(s: In, tu: Ast.TransUnit) = + override def transUnit(s: State, tu: Ast.TransUnit) = tu.members.flatMap(matchModuleMember(s, _)) private def writeSpecLoc[T]( - s: In, + s: State, kind: Ast.SpecLoc.Kind, name: String, node: AstNode[T] diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala index 4e4b61e28..3febf5c3e 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ArrayXmlWriter.scala @@ -11,9 +11,9 @@ object ArrayXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil - override def defArrayAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val node = aNode._2 val data = node.data val tags = { @@ -74,7 +74,7 @@ object ArrayXmlWriter extends AstVisitor with LineUtils { /** Writes the default value corresponding to an array value */ def writeDefaultValue( - s: In, + s: XmlWriterState, arrayValue: Value.Array ): Out = { val tags = XmlTags.tags("value") diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala index 0e26b2712..d77c09dc5 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ComponentXmlWriter.scala @@ -12,7 +12,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] override def defComponentAnnotatedNode( - s: In, + s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val symbol = Symbol.Component(aNode) @@ -37,9 +37,9 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines ("component", pairs) (body.map(indentIn)) } - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil - private def writeCommands(s: In, c: Component) = { + private def writeCommands(s: XmlWriterState, c: Component) = { import Command._ def writeNonParamCommand(opcode: Opcode, nonParam: NonParam) = { import NonParam._ @@ -85,7 +85,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("commands") (commands.map(indentIn)) } - private def writeEvents(s: In, c: Component) = { + private def writeEvents(s: XmlWriterState, c: Component) = { import Event._ def writeEvent(id: Id, event: Event) = { val data = event.aNode._2.data @@ -131,12 +131,12 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("events") (events.map(indentIn)) } - private def writeImports(s: In, c: Component) = { + private def writeImports(s: XmlWriterState, c: Component) = { val Right(a) = UsedSymbols.defComponentAnnotatedNode(s.a, c.aNode) s.writeImportDirectives(a.usedSymbolSet) } - private def writeInternalInterfaces(s: In, c: Component) = { + private def writeInternalInterfaces(s: XmlWriterState, c: Component) = { def writeInternalPort(name: String, internal: PortInstance.Internal) = { import PortInstance.Internal._ val data = internal.aNode._2.data @@ -165,7 +165,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("internal_interfaces") (ports.map(indentIn)) } - private def writeParams(s: In, c: Component) = { + private def writeParams(s: XmlWriterState, c: Component) = { import Param._ def writeParam(id: Id, param: Param) = { val data = param.aNode._2.data @@ -190,7 +190,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("parameters") (params.map(indentIn)) } - private def writePorts(s: In, c: Component) = { + private def writePorts(s: XmlWriterState, c: Component) = { def writeGeneralPort(name: String, general: PortInstance.General) = { import PortInstance.General._ def writeDataType(ty: PortInstance.Type) = ty match { @@ -268,7 +268,7 @@ object ComponentXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLinesOpt ("ports") (ports.map(indentIn)) } - private def writeTlmChannels(s: In, c: Component) = { + private def writeTlmChannels(s: XmlWriterState, c: Component) = { import TlmChannel._ def writeTlmChannel(id: Id, tlmChannel: TlmChannel) = { val data = tlmChannel.aNode._2.data diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala index 64ac94728..4c04db346 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/EnumXmlWriter.scala @@ -11,9 +11,9 @@ object EnumXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil - override def defEnumAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val node = aNode._2 val data = node.data val enumType @ Type.Enum(_, _, _) = s.a.typeMap(node.id) @@ -37,7 +37,7 @@ object EnumXmlWriter extends AstVisitor with LineUtils { } def defEnumConstantAnnotatedNode( - s: In, + s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnumConstant]] ): Line = { val node = aNode._2 diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala index 8a0c7485f..62c153c74 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/PortXmlWriter.scala @@ -11,10 +11,10 @@ object PortXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil override def defPortAnnotatedNode( - s: In, + s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]] ) = { val node = aNode._2 diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala index 0f276a1f3..a38be12ae 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/StructXmlWriter.scala @@ -11,9 +11,9 @@ object StructXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil - override def defStructAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val node = aNode._2 val data = node.data val tags = { @@ -36,7 +36,7 @@ object StructXmlWriter extends AstVisitor with LineUtils { } def structTypeMemberAnnotatedNode( - s: In, + s: XmlWriterState, structType: Type.Struct, aNode: Ast.Annotated[AstNode[Ast.StructTypeMember]] ): Out = { diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala index 94beded6a..6620ca7fb 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TopologyXmlWriter.scala @@ -12,7 +12,7 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { type Out = List[Line] override def defTopologyAnnotatedNode( - s: In, + s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]] ) = { val symbol = Symbol.Topology(aNode) @@ -29,14 +29,14 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { XmlTags.taggedLines ("assembly", pairs) (body.map(indentIn)) } - override def default(s: In) = Nil + override def default(s: XmlWriterState) = Nil - private def writeImports(s: In, t: Topology) = { + private def writeImports(s: XmlWriterState, t: Topology) = { val symbols = t.instanceMap.keys.map(ci => Symbol.Component(ci.component.aNode)) s.writeImportDirectives(symbols) } - private def writeInstances(s: In, t: Topology) = { + private def writeInstances(s: XmlWriterState, t: Topology) = { def writeInstance(ci: ComponentInstance) = { val cis = Symbol.ComponentInstance(ci.aNode) val cs = Symbol.Component(ci.component.aNode) @@ -58,7 +58,7 @@ object TopologyXmlWriter extends AstVisitor with LineUtils { instances.flatMap(writeInstance).toList } - private def writeConnections(s: In, t: Topology) = { + private def writeConnections(s: XmlWriterState, t: Topology) = { def getPairs( endpoint: Connection.Endpoint, portNumber: Int diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala index 5a2324579..0afb7f192 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/TypeXmlWriter.scala @@ -12,26 +12,26 @@ object TypeXmlWriter { type Out = String - override def absType(s: In, t: Type.AbsType) = + override def absType(s: XmlWriterState, t: Type.AbsType) = s.writeSymbol(Symbol.AbsType(t.node)) - override def array(s: In, t: Type.Array) = + override def array(s: XmlWriterState, t: Type.Array) = s.writeSymbol(Symbol.Array(t.node)) - override def boolean(s: In) = "bool" + override def boolean(s: XmlWriterState) = "bool" - override def default(s: In, t: Type) = throw new InternalError("visitor not defined") + override def default(s: XmlWriterState, t: Type) = throw new InternalError("visitor not defined") - override def enumeration(s: In, t: Type.Enum) = + override def enumeration(s: XmlWriterState, t: Type.Enum) = s.writeSymbol(Symbol.Enum(t.node)) - override def float(s: In, t: Type.Float) = t.toString + override def float(s: XmlWriterState, t: Type.Float) = t.toString - override def primitiveInt(s: In, t: Type.PrimitiveInt) = t.toString + override def primitiveInt(s: XmlWriterState, t: Type.PrimitiveInt) = t.toString - override def string(s: In, t: Type.String) = "string" + override def string(s: XmlWriterState, t: Type.String) = "string" - override def struct(s: In, t: Type.Struct) = + override def struct(s: XmlWriterState, t: Type.Struct) = s.writeSymbol(Symbol.Struct(t.node)) } diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala index ff295acfe..82dcb165f 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/ValueXmlWriter.scala @@ -13,7 +13,7 @@ object ValueXmlWriter { type Out = String - override def absType(s: In, v: Value.AbsType) = { + override def absType(s: XmlWriterState, v: Value.AbsType) = { val aNode = v.t.node val cppName = s.writeSymbol(Symbol.AbsType(aNode)) s.builtInTypes.get(cppName) match { @@ -22,21 +22,21 @@ object ValueXmlWriter { } } - override def array(s: In, v: Value.Array) = { + override def array(s: XmlWriterState, v: Value.Array) = { val elements = v.anonArray.elements.map(getValue(s, _)) val stringify = elements.mkString(", ") TypeXmlWriter.getName(s, v.getType) ++ "(" ++ stringify ++ ")" } - override def boolean(s: In, v: Value.Boolean) = v.value.toString + override def boolean(s: XmlWriterState, v: Value.Boolean) = v.value.toString - override def default(s: In, v: Value) = + override def default(s: XmlWriterState, v: Value) = throw new InternalError("visitor not defined") - override def enumConstant(s: In, v: Value.EnumConstant) = + override def enumConstant(s: XmlWriterState, v: Value.EnumConstant) = TypeXmlWriter.getName(s, v.getType) ++ "::" ++ v.value._1.toString - override def float(s: In, v: Value.Float) = { + override def float(s: XmlWriterState, v: Value.Float) = { val s = v.value.toString v.kind match { case Type.Float.F32 => s"${s}f" @@ -44,17 +44,17 @@ object ValueXmlWriter { } } - override def integer(s: In, v: Value.Integer) = v.value.toString + override def integer(s: XmlWriterState, v: Value.Integer) = v.value.toString - override def primitiveInt(s: In, v: Value.PrimitiveInt) = v.value.toString + override def primitiveInt(s: XmlWriterState, v: Value.PrimitiveInt) = v.value.toString - override def string(s: In, v: Value.String) = + override def string(s: XmlWriterState, v: Value.String) = "\"" ++ v.value.toString.replaceAll("\\\\", "\\\\\\\\"). replaceAll("\"", "\\\\\"").replaceAll("\n", "\\\\n") ++ "\"" - override def struct(s: In, v: Value.Struct) = { + override def struct(s: XmlWriterState, v: Value.Struct) = { val structType = v.getType val data = structType.node._2.data val namesList = data.members diff --git a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala index 5c960da83..955d544dd 100644 --- a/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala +++ b/compiler/lib/src/main/scala/codegen/XmlWriter/XmlWriter.scala @@ -9,7 +9,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { type State = XmlWriterState - override def defArrayAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { + override def defArrayAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefArray]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Array(aNode)) @@ -18,7 +18,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defComponentAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { + override def defComponentAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Component(aNode)) @@ -31,7 +31,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { yield s } - override def defEnumAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { + override def defEnumAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefEnum]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Enum(aNode)) @@ -41,7 +41,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { } override def defModuleAnnotatedNode( - s: In, + s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (_, node, _) = aNode @@ -49,7 +49,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { visitList(s, data.members, matchModuleMember) } - override def defPortAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { + override def defPortAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefPort]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Port(aNode)) @@ -58,7 +58,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def defStructAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { + override def defStructAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefStruct]]) = { val (_, node, _) = aNode val loc = Locations.get(node.id) val data = node.data @@ -71,7 +71,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { } yield s } - override def defTopologyAnnotatedNode(s: In, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { + override def defTopologyAnnotatedNode(s: XmlWriterState, aNode: Ast.Annotated[AstNode[Ast.DefTopology]]) = { val (_, node, _) = aNode val data = node.data val name = s.getName(Symbol.Topology(aNode)) @@ -80,7 +80,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { writeXmlFile(s, fileName, lines) } - override def transUnit(s: In, tu: Ast.TransUnit) = + override def transUnit(s: XmlWriterState, tu: Ast.TransUnit) = visitList(s, tu.members, matchTuMember) private def writeXmlHeader(fileName: String) = lines( @@ -93,7 +93,7 @@ object XmlWriter extends AstStateVisitor with LineUtils { |""" ) - private def writeXmlFile(s: In, fileName: String, lines: List[Line]) = { + private def writeXmlFile(s: XmlWriterState, fileName: String, lines: List[Line]) = { val path = java.nio.file.Paths.get(s.dir, fileName) val file = File.Path(path) val headerLines = writeXmlHeader(fileName) diff --git a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala index 94921a6db..74aa74191 100644 --- a/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala +++ b/compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala @@ -10,10 +10,10 @@ object ResolveSpecInclude extends AstStateTransformer { type State = Analysis - def default(a: In) = a + def default(a: Analysis) = a override def defComponentAnnotatedNode( - a: In, + a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponent]] ) = { val (pre, node1, post) = node @@ -28,7 +28,7 @@ object ResolveSpecInclude extends AstStateTransformer { } override def defModuleAnnotatedNode( - a: In, + a: Analysis, node: Ast.Annotated[AstNode[Ast.DefModule]] ) = { val (pre, node1, post) = node @@ -42,7 +42,7 @@ object ResolveSpecInclude extends AstStateTransformer { } } - override def transUnit(a: In, tu: Ast.TransUnit) = { + override def transUnit(a: Analysis, tu: Ast.TransUnit) = { for { result <- transformList(a, tu.members, tuMember) } yield (result._1, Ast.TransUnit(result._2.flatten)) } From bff233b381f33e590f950c5c60b3a033d942ae3c Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Tue, 17 May 2022 17:51:03 -0700 Subject: [PATCH 12/14] native-image-agent instrumentation files --- compiler/.gitignore | 1 + .../META-INF/native-image/jni-config.json | 2 ++ .../META-INF/native-image/proxy-config.json | 2 ++ .../META-INF/native-image/reflect-config.json | 20 +++++++++++++++++++ .../native-image/resource-config.json | 5 +++++ .../native-image/serialization-config.json | 2 ++ 6 files changed, 32 insertions(+) create mode 100644 compiler/lib/src/main/resources/META-INF/native-image/jni-config.json create mode 100644 compiler/lib/src/main/resources/META-INF/native-image/proxy-config.json create mode 100644 compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json create mode 100644 compiler/lib/src/main/resources/META-INF/native-image/resource-config.json create mode 100644 compiler/lib/src/main/resources/META-INF/native-image/serialization-config.json diff --git a/compiler/.gitignore b/compiler/.gitignore index 9c26fcc40..6ea88c661 100644 --- a/compiler/.gitignore +++ b/compiler/.gitignore @@ -3,3 +3,4 @@ num_failed.txt target/ test-output.txt *.o +native-fpp-Linux-x86_64 diff --git a/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json b/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json new file mode 100644 index 000000000..0d4f101c7 --- /dev/null +++ b/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json @@ -0,0 +1,2 @@ +[ +] diff --git a/compiler/lib/src/main/resources/META-INF/native-image/proxy-config.json b/compiler/lib/src/main/resources/META-INF/native-image/proxy-config.json new file mode 100644 index 000000000..0d4f101c7 --- /dev/null +++ b/compiler/lib/src/main/resources/META-INF/native-image/proxy-config.json @@ -0,0 +1,2 @@ +[ +] diff --git a/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json new file mode 100644 index 000000000..6deb06549 --- /dev/null +++ b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json @@ -0,0 +1,20 @@ +[ +{ + "name":"java.lang.ClassValue" +}, +{ + "name":"java.lang.String[]" +}, +{ + "name":"java.lang.invoke.VarHandle", + "methods":[{"name":"releaseFence","parameterTypes":[] }] +}, +{ + "name":"scopt.OParser$", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"sun.misc.Unsafe", + "allDeclaredFields":true +} +] diff --git a/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json b/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json new file mode 100644 index 000000000..791ea0f4c --- /dev/null +++ b/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json @@ -0,0 +1,5 @@ +{ + "resources":{ + "includes":[]}, + "bundles":[] +} diff --git a/compiler/lib/src/main/resources/META-INF/native-image/serialization-config.json b/compiler/lib/src/main/resources/META-INF/native-image/serialization-config.json new file mode 100644 index 000000000..0d4f101c7 --- /dev/null +++ b/compiler/lib/src/main/resources/META-INF/native-image/serialization-config.json @@ -0,0 +1,2 @@ +[ +] From 24209c59261846b3be353a3ae439f6badc95d802 Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Wed, 18 May 2022 09:16:42 -0700 Subject: [PATCH 13/14] Updated bin/fpp-syntax with -agentlib:native-image-agent=config-output-dir=; release; ./native-fpp-Linux-x86_64/fpp-syntax ./tools/fpp-syntax/test/syntax.fpp --- .../META-INF/native-image/jni-config.json | 7 +++++++ .../META-INF/native-image/reflect-config.json | 21 +++++++++++++++++-- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json b/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json index 0d4f101c7..7d5fedc5b 100644 --- a/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json +++ b/compiler/lib/src/main/resources/META-INF/native-image/jni-config.json @@ -1,2 +1,9 @@ [ +{ + "name":"java.lang.ClassLoader", + "methods":[{"name":"getPlatformClassLoader","parameterTypes":[] }] +}, +{ + "name":"java.lang.NoSuchMethodError" +} ] diff --git a/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json index 6deb06549..f5d93467b 100644 --- a/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json +++ b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json @@ -1,14 +1,31 @@ [ { - "name":"java.lang.ClassValue" + "name":"fpp.compiler.syntax.Lexer$", + "fields":[{"name":"0bitmap$2", "allowUnsafeAccess":true}] }, { - "name":"java.lang.String[]" + "name":"fpp.compiler.syntax.Lexer$$anon$1", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"fpp.compiler.syntax.Parser$", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"java.lang.ClassValue" }, { "name":"java.lang.invoke.VarHandle", "methods":[{"name":"releaseFence","parameterTypes":[] }] }, +{ + "name":"scala.util.parsing.input.OffsetPosition", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"scala.util.parsing.input.OffsetPosition$", + "fields":[{"name":"0bitmap$2", "allowUnsafeAccess":true}] +}, { "name":"scopt.OParser$", "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] From 2f5ce04ddf6df9f000af9334d91471c77514452b Mon Sep 17 00:00:00 2001 From: Nicolas Rouquette Date: Thu, 19 May 2022 18:04:26 -0700 Subject: [PATCH 14/14] native configuration passes all tests --- compiler/install | 5 ++- .../META-INF/native-image/reflect-config.json | 36 +++++++++++++++++++ .../native-image/resource-config.json | 2 +- compiler/tools/fpp-format/test/run | 7 ++-- compiler/tools/fpp-to-xml/test/port/run.sh | 4 ++- 5 files changed, 48 insertions(+), 6 deletions(-) diff --git a/compiler/install b/compiler/install index 88e272216..d885c803f 100755 --- a/compiler/install +++ b/compiler/install @@ -25,6 +25,8 @@ fi wd=`dirname $0` cd $wd +top=`pwd` +meta=$top/lib/src/main/resources/META-INF/native-image dir=`dirname $dest` dir=`cd $dir; pwd` @@ -68,6 +70,7 @@ do cp $jar $dest/$tool.jar echo '#!/bin/sh - java -jar '$dest'/'$tool'.jar "$@"' > $dest/$tool + # See https://www.graalvm.org/22.1/reference-manual/native-image/Agent/ + java -agentlib:native-image-agent=config-merge-dir='$meta' -jar '$dest'/'$tool'.jar "$@"' > $dest/$tool chmod +x $dest/$tool done diff --git a/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json index f5d93467b..6404a8b36 100644 --- a/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json +++ b/compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json @@ -1,4 +1,29 @@ [ +{ + "name":"com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"fpp.compiler.analysis.ComponentInstance[]" +}, +{ + "name":"fpp.compiler.analysis.Connection[]" +}, +{ + "name":"fpp.compiler.analysis.Format$Parser$", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"fpp.compiler.codegen.CppDocCppWriter$", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"fpp.compiler.codegen.CppDocHppWriter$", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, +{ + "name":"fpp.compiler.codegen.Line[]" +}, { "name":"fpp.compiler.syntax.Lexer$", "fields":[{"name":"0bitmap$2", "allowUnsafeAccess":true}] @@ -14,6 +39,9 @@ { "name":"java.lang.ClassValue" }, +{ + "name":"java.lang.String[]" +}, { "name":"java.lang.invoke.VarHandle", "methods":[{"name":"releaseFence","parameterTypes":[] }] @@ -26,6 +54,14 @@ "name":"scala.util.parsing.input.OffsetPosition$", "fields":[{"name":"0bitmap$2", "allowUnsafeAccess":true}] }, +{ + "name":"scala.xml.XML$", + "fields":[{"name":"0bitmap$2", "allowUnsafeAccess":true}] +}, +{ + "name":"scala.xml.parsing.FactoryAdapter", + "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] +}, { "name":"scopt.OParser$", "fields":[{"name":"0bitmap$1", "allowUnsafeAccess":true}] diff --git a/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json b/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json index 791ea0f4c..8d7333115 100644 --- a/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json +++ b/compiler/lib/src/main/resources/META-INF/native-image/resource-config.json @@ -1,5 +1,5 @@ { "resources":{ "includes":[]}, - "bundles":[] + "bundles":[{"name":"com.sun.org.apache.xerces.internal.impl.msg.XMLMessages"}] } diff --git a/compiler/tools/fpp-format/test/run b/compiler/tools/fpp-format/test/run index aa454a957..28e34a609 100755 --- a/compiler/tools/fpp-format/test/run +++ b/compiler/tools/fpp-format/test/run @@ -3,6 +3,7 @@ . ../../../scripts/test-utils.sh fpp_format=../../../bin/fpp-format +fpp_syntax=../../../bin/fpp-syntax compare() { @@ -40,19 +41,19 @@ done > default-tests.sh include() { run_test '-i' syntax include && \ - fpp-syntax include.out.txt + $fpp_syntax include.out.txt } kwd_names() { run_test '' kwd_names && \ - fpp-syntax kwd_names.out.txt + $fpp_syntax kwd_names.out.txt } no_include() { run_test '' syntax no_include && \ - fpp-syntax no_include.out.txt + $fpp_syntax no_include.out.txt } run_suite $tests diff --git a/compiler/tools/fpp-to-xml/test/port/run.sh b/compiler/tools/fpp-to-xml/test/port/run.sh index a37afb21d..8f79ffb03 100644 --- a/compiler/tools/fpp-to-xml/test/port/run.sh +++ b/compiler/tools/fpp-to-xml/test/port/run.sh @@ -1,5 +1,7 @@ #!/bin/sh +fpp_depend=../../../../bin/fpp-depend + port_kwd_name() { run_test "-p $PWD" port_kwd_name && \ @@ -10,7 +12,7 @@ port_ok() { files="" for i in `seq 1 4`; do files="$files PortOK${i}Port"; done - run_test "-i `fpp-depend port_ok.fpp | tr '\n' ','` -p $PWD" port_ok && \ + run_test "-i `$fpp_depend port_ok.fpp | tr '\n' ','` -p $PWD" port_ok && \ diff_xml $files }