Refactor CheckUses

Author: bocchino

compiler/lib/src/main/scala/analysis/Analyzers/BasicUseAnalyzer.scala

@@ -34,25 +34,31 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
   def stateMachineUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
   /** An implied constant use */
-  def impliedConstantUse(a: Analysis, iu: ImpliedUse) =
-    for {
-      a <- iu.annotateResult(exprNode(a, iu.asExprNode))
+  def impliedConstantUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- exprNode(a, iu.asExprNode)
       _ <- impliedUse(a, iu, ImpliedUse.Kind.Constant)
     } yield a
+    iu.annotateResult(result)
+  }
 
   /** An implied port use */
-  def impliedPortUse(a: Analysis, iu: ImpliedUse) =
-    for {
-      a <- iu.annotateResult(portUse(a, iu.asQualIdentNode, iu.name))
+  def impliedPortUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- portUse(a, iu.asQualIdentNode, iu.name)
       _ <- impliedUse(a, iu, ImpliedUse.Kind.Port)
     } yield a
+    iu.annotateResult(result)
+  }
 
   /** An implied type use */
-  def impliedTypeUse(a: Analysis, iu: ImpliedUse) =
-    for {
-      a <- iu.annotateResult(typeUse(a, iu.asTypeNameNode, iu.name))
+  def impliedTypeUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- typeUse(a, iu.asTypeNameNode, iu.name)
       _ <- impliedUse(a, iu, ImpliedUse.Kind.Type)
     } yield a
+    iu.annotateResult(result)
+  }
 
   /** An implied use */
   def impliedUse(a: Analysis, iu: ImpliedUse, kind: ImpliedUse.Kind): Result =

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala

@@ -88,25 +88,24 @@ object CheckUses extends BasicUseAnalyzer {
     val symQualifiedName = a.getQualifiedName(sym).toString
     val iuName = iu.name.toString
     // Check that the name of the def matches the name of the use
-    val result = if symQualifiedName == iuName
-      // OK, they match
-      then Right(a)
-      else {
-        val msg = if symQualifiedName.length < iuName.length
-        // Definition has a shorter name: the use is a member of the definition
-        then s"it has $iuName as a member"
-        // Definition has a longer name: it shadows the required definition
-        else s"it shadows $iuName here"
-        Left(
-          SemanticError.InvalidSymbol(
-            symQualifiedName,
-            Locations.get(iu.id),
-            msg,
-            sym.getLoc
-          )
+    if symQualifiedName == iuName
+    // OK, they match
+    then Right(a)
+    else {
+      val msg = if symQualifiedName.length < iuName.length
+      // Definition has a shorter name: the use is a member of the definition
+      then s"it has $iuName as a member"
+      // Definition has a longer name: it shadows the required definition
+      else s"it shadows $iuName here"
+      Left(
+        SemanticError.InvalidSymbol(
+          symQualifiedName,
+          Locations.get(iu.id),
+          msg,
+          sym.getLoc
         )
-      }
-    iu.annotateResult(result)
+      )
+    }
   }
 
   override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = {