Hoist declarations, reduce nesting refactorings

Author: kevinlano

BehaviouralFeature.java

@@ -11162,17 +11162,17 @@ public void hoistLocalDeclarations()
           ModelElement.lookupByName(vname, parameters); 
 
       if (par != null) 
-      { System.err.println("!! Warning: " + vname + " is both a parameter and local variable!"); 
+      { System.err.println("!! Code Smell (MDV): " + vname + " is both a parameter and a local variable!"); 
         continue; 
       }
 
       if (varnames.contains(vname))
-      { System.err.println("!! Warning: multiple declarations for variable " + vname); 
+      { System.err.println("!! Code Smell (MDV): multiple declarations in same scope for variable " + vname); 
         continue;
       } 
 
       varnames.add(vname); 
-      initialDecs.add(cs); 
+      initialDecs.add(cs.defaultVersion()); 
     } 
 
     if (varnames.size() == 0) 
@@ -11186,6 +11186,23 @@ public void hoistLocalDeclarations()
     System.out.println(">>> New activity: " + ss); 
     activity = ss; 
   } 
+
+  public void reduceCodeNesting()
+  { // Replace each conditional  
+    // if cond then stats1 else stats2 
+    // by 
+    // if cond then stats1 else skip; stats2
+    // where all code paths in stats1 end with a return. 
+
+    if (activity == null) 
+    { return; } 
+
+    Statement newactivity = 
+      Statement.replaceElseBySequence(activity); 
+       
+    System.out.println(">>> New activity: " + newactivity); 
+    activity = newactivity; 
+  } 
 }
 
 

Statement.java

@@ -193,6 +193,55 @@ public static Vector getReturnValues(Statement st)
     return res;
   } // Other cases, for all other forms of statement. 
 
+  public static boolean endsWithReturn(Statement st)
+  { if (st == null) 
+    { return false; }
+ 
+    if (st instanceof SequenceStatement) 
+    { SequenceStatement sq = (SequenceStatement) st; 
+      Vector stats = sq.getStatements(); 
+      Statement stat = (Statement) stats.get(stats.size()-1); 
+      return Statement.endsWithReturn(stat);
+    } 
+    
+    if (st instanceof ReturnStatement)
+    { return true; } 
+
+    if (st instanceof ConditionalStatement) 
+    { ConditionalStatement cs = (ConditionalStatement) st; 
+      if (Statement.endsWithReturn(cs.ifPart()))
+      { return Statement.endsWithReturn(cs.elsePart()); } 
+      return false; 
+    } 
+
+    if (st instanceof WhileStatement) 
+    { return false; } 
+
+    if (st instanceof TryStatement) 
+    { TryStatement ts = (TryStatement) st; 
+
+      if (Statement.endsWithReturn(ts.getBody())) 
+      { Vector stats = ts.getClauses(); 
+        for (int i = 0; i < stats.size(); i++) 
+        { if (stats.get(i) instanceof Statement)
+          { Statement stat = (Statement) stats.get(i); 
+            if (Statement.endsWithReturn(stat)) { } 
+            else 
+            { return false; } 
+          }
+          else 
+          { return false; } 
+        }  
+      }
+      else 
+      { return false; }  
+      if (ts.getEndStatement() == null) { return false; } 
+      return Statement.endsWithReturn(ts.getEndStatement()); 
+    } 
+
+    return false;
+  } // Other cases, for all other forms of statement. 
+
   public static Statement replaceReturnBySkip(Statement st)
   { if (st == null) 
     { return st; }
@@ -269,8 +318,101 @@ public static Statement replaceReturnBySkip(Statement st)
     return st;
   } // Other cases, for all other forms of statement. 
 
+  public static Statement replaceElseBySequence(Statement st)
+  { if (st == null) 
+    { return st; }
+ 
+    if (st instanceof SequenceStatement) 
+    { SequenceStatement sq = (SequenceStatement) st; 
+      Vector newstats = new Vector(); 
+      Vector stats = sq.getStatements(); 
+      for (int i = 0; i < stats.size(); i++) 
+      { if (stats.get(i) instanceof Statement)
+        { Statement stat = (Statement) stats.get(i); 
+          Statement newstat = 
+            Statement.replaceElseBySequence(stat);
+          newstats.add(newstat); 
+        }  
+      } 
+
+      SequenceStatement newsq = 
+            new SequenceStatement(newstats);
+      newsq.setBrackets(sq.hasBrackets());  
+      return newsq; 
+    } 
+    
+    if (st instanceof ReturnStatement)
+    { return st; } 
+
+    if (st instanceof ConditionalStatement) 
+    { ConditionalStatement cs = (ConditionalStatement) st; 
+      Statement newif = 
+         Statement.replaceElseBySequence(cs.ifPart()); 
+      Statement newelse = 
+         Statement.replaceElseBySequence(cs.elsePart());
+      if (Statement.endsWithReturn(newif))
+      { ConditionalStatement res = 
+          new ConditionalStatement(cs.getTest(), 
+                newif, 
+                new InvocationStatement("skip"));
+        SequenceStatement ss = new SequenceStatement(); 
+        ss.addStatement(res); 
+        ss.addStatement(newelse); 
+        return ss; 
+      } 
+      else 
+      { ConditionalStatement res = 
+          new ConditionalStatement(cs.getTest(), 
+                newif, 
+                newelse);
+  
+        return res;
+      } 
+    } 
+
+    if (st instanceof WhileStatement) 
+    { WhileStatement ws = (WhileStatement) st; 
+      Statement newbody = 
+         Statement.replaceElseBySequence(ws.getLoopBody());
+      WhileStatement wsnew = 
+        new WhileStatement(ws.getTest(), newbody); 
+      wsnew.loopKind = ws.loopKind;  
+      wsnew.loopVar = ws.loopVar;
+      wsnew.loopRange = ws.loopRange;
+  
+      return wsnew; 
+    } 
+
+    if (st instanceof TryStatement) 
+    { TryStatement ts = (TryStatement) st; 
+      Statement newbody = 
+         Statement.replaceElseBySequence(ts.getBody());
+      Vector newclauses = new Vector();  
+      Vector stats = ts.getClauses(); 
+      for (int i = 0; i < stats.size(); i++) 
+      { if (stats.get(i) instanceof Statement)
+        { Statement stat = (Statement) stats.get(i); 
+          Statement newstat = 
+             Statement.replaceElseBySequence(stat);
+          newclauses.add(newstat); 
+        }  
+      } 
+      
+      Statement newend = 
+         Statement.replaceElseBySequence(
+                             ts.getEndStatement()); 
+      TryStatement newtry = 
+         new TryStatement(newbody, newclauses, newend); 
+      return newtry; 
+    } 
+
+    return st;
+  } // Other cases, for all other forms of statement. 
+
   public static Vector getLocalDeclarations(Statement st)
-  { Vector res = new Vector(); 
+  { // Local declarations that are not within a loop 
+
+    Vector res = new Vector(); 
     if (st == null) 
     { return res; }
 
@@ -300,7 +442,7 @@ public static Vector getLocalDeclarations(Statement st)
 
     if (st instanceof WhileStatement) 
     { WhileStatement ws = (WhileStatement) st; 
-      res.addAll(getLocalDeclarations(ws.getLoopBody())); 
+      // res.addAll(getLocalDeclarations(ws.getLoopBody())); 
       return res; 
     } 
 
@@ -869,7 +1011,7 @@ public static Statement replaceLocalDeclarations(Statement st, Vector vars)
       return res; 
     } 
 
-    if (st instanceof WhileStatement) 
+    /* if (st instanceof WhileStatement) 
     { WhileStatement ws = (WhileStatement) st; 
       Statement newbody = 
         Statement.replaceLocalDeclarations(
@@ -880,7 +1022,7 @@ public static Statement replaceLocalDeclarations(Statement st, Vector vars)
       return res;  
     } 
 
-    /* if (st instanceof TryStatement) 
+    if (st instanceof TryStatement) 
     { TryStatement ts = (TryStatement) st; 
       res.addAll(getLocalDeclarations(ts.getBody())); 
       Vector stats = ts.getClauses(); 
@@ -5393,6 +5535,19 @@ class CreationStatement extends Statement
   boolean isFrozen = false;  // true when a constant is declared. 
   Attribute variable = null; // for the LHS
 
+  public Object clone()
+  { CreationStatement cs = 
+       new CreationStatement(createsInstanceOf,assignsTo); 
+    cs.instanceType = instanceType; 
+    cs.elementType = elementType; 
+    cs.declarationOnly = declarationOnly; 
+    cs.initialValue = initialValue; 
+    cs.initialExpression = (Expression) initialExpression.clone(); 
+    cs.isFrozen = isFrozen; 
+    cs.variable = variable; 
+    return cs; 
+  } 
+
   public Type getType()
   { return instanceType; } 
 
@@ -5449,6 +5604,15 @@ public CreationStatement(Expression vbl, Type typ)
     assignsTo = vbl + ""; 
   }
 
+  public CreationStatement defaultVersion()
+  { CreationStatement res = (CreationStatement) clone(); 
+    Expression defaultInit = 
+      Type.defaultInitialValueExpression(instanceType);
+    res.initialExpression = defaultInit; 
+    res.initialValue = defaultInit + ""; 
+    return res; 
+  } 
+
 
   /* public CreationStatement(Attribute vbl, Type typ)
   { createsInstanceOf = typ.getName();
@@ -5577,9 +5741,6 @@ public void setElementType(Type t)
     { instanceType.setElementType(t); }  
   } 
 
-  public Object clone()
-  { return this; } 
-
   public Statement dereference(BasicExpression var)
   { return this; } 
 

UCDArea.java

@@ -6692,6 +6692,78 @@ else if (effect == stat)
     System.out.println(">> Set activity for operation " + nme + " of entity " + ent); 
   }
 
+  public void hoistOperationLocalDecs(Entity ent)
+  { String nme = 
+          JOptionPane.showInputDialog("Enter operation name:");
+    BehaviouralFeature bf = ent.getOperation(nme); 
+    if (bf == null) 
+    { System.err.println("!! ERROR: No such operation: " + nme); 
+      return; 
+    } 
+
+    Statement stat = bf.getActivity();
+    bf.hoistLocalDeclarations(); 
+    Statement effect = bf.getActivity(); 
+ 
+    if (effect == null)
+    { System.err.println("!!! ERROR: Syntax error in activity"); 
+      return; 
+    } 
+    else if (effect == stat) 
+    { System.out.println(">>> No change to activity"); 
+      return; 
+    } 
+    
+    Vector contexts = new Vector(); 
+    contexts.add(ent); 
+    Vector pars = new Vector(); 
+
+    effect.setEntity(ent); 
+    pars.addAll(bf.getParameters()); 
+
+    effect.typeCheck(types,entities,contexts,pars); 
+    
+    bf.setActivity(effect); 
+    updateActivities(ent, bf, effect); 
+    System.out.println(">> Set activity for operation " + nme + " of entity " + ent); 
+  }
+
+  public void reduceCodeNesting(Entity ent)
+  { String nme = 
+          JOptionPane.showInputDialog("Enter operation name:");
+    BehaviouralFeature bf = ent.getOperation(nme); 
+    if (bf == null) 
+    { System.err.println("!! ERROR: No such operation: " + nme); 
+      return; 
+    } 
+
+    Statement stat = bf.getActivity();
+    bf.reduceCodeNesting(); 
+    Statement effect = bf.getActivity(); 
+ 
+    if (effect == null)
+    { System.err.println("!!! ERROR: Syntax error in activity"); 
+      return; 
+    } 
+    else if (effect == stat) 
+    { System.out.println(">>> No change to activity"); 
+      return; 
+    } 
+    
+    Vector contexts = new Vector(); 
+    contexts.add(ent); 
+    Vector pars = new Vector(); 
+
+    effect.setEntity(ent); 
+    pars.addAll(bf.getParameters()); 
+
+    effect.typeCheck(types,entities,contexts,pars); 
+    
+    bf.setActivity(effect); 
+    updateActivities(ent, bf, effect); 
+    System.out.println(">> Set activity for operation " + nme + " of entity " + ent); 
+  }
+
   public void replaceCallsByDefinitions(Entity ent)
   { String nme = 
       JOptionPane.showInputDialog("Name of operation to be replaced by its code:");