Index: src/ResolvExpr/CandidateFinder.cpp
===================================================================
--- src/ResolvExpr/CandidateFinder.cpp	(revision 38093ae64b024ab4c59bfa2d4555f10ec56e103e)
+++ src/ResolvExpr/CandidateFinder.cpp	(revision fc1a3e283512526d1ddc12898c7c5fa33f0ddeaf)
@@ -1412,10 +1412,10 @@
 	}
 
-    void Finder::postvisit(const ast::VariableExpr *variableExpr) {
-        // not sufficient to just pass `variableExpr` here, type might have changed
-
-        auto cand = new Candidate(variableExpr, tenv);
-        candidates.emplace_back(cand);
-    }
+	void Finder::postvisit(const ast::VariableExpr *variableExpr) {
+		// not sufficient to just pass `variableExpr` here, type might have changed
+
+		auto cand = new Candidate(variableExpr, tenv);
+		candidates.emplace_back(cand);
+	}
 
 	void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {
@@ -2133,6 +2133,6 @@
 
 // get the valueE(...) ApplicationExpr that returns the enum value
-const ast::Expr * getValueEnumCall( 
-	const ast::Expr * expr, 
+const ast::Expr * getValueEnumCall(
+	const ast::Expr * expr,
 	const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
 		auto callExpr = new ast::UntypedExpr(
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision 38093ae64b024ab4c59bfa2d4555f10ec56e103e)
+++ src/ResolvExpr/CommonType.cc	(revision fc1a3e283512526d1ddc12898c7c5fa33f0ddeaf)
@@ -397,15 +397,15 @@
 			}
 		} else if ( auto type2AsAttr = dynamic_cast< const ast::EnumAttrType * >( type2 ) ) {
-            if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
-			    ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
-			    if (
-				    ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
-					    || widen.first )
-				    && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
-					    || widen.second )
-			    ) {
-				    result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
-			    }
-            }
+			if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
+				ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
+				if (
+					( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+						|| widen.first )
+					&& ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+						|| widen.second )
+				) {
+					result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+				}
+			}
 		}
 	}
@@ -519,5 +519,5 @@
 								// xxx - assume LHS is always the target type
 
-								if ( ! ((widen.second && ref2->qualifiers.is_mutex) 
+								if ( ! ((widen.second && ref2->qualifiers.is_mutex)
 								|| (ref1->qualifiers.is_mutex == ref2->qualifiers.is_mutex ))) return;
 
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision 38093ae64b024ab4c59bfa2d4555f10ec56e103e)
+++ src/ResolvExpr/ConversionCost.cc	(revision fc1a3e283512526d1ddc12898c7c5fa33f0ddeaf)
@@ -379,28 +379,28 @@
 
 void ConversionCost::postvisit( const ast::EnumAttrType * src ) {
-    auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
+	auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
 	assert( src->attr != ast::EnumAttribute::Label );
-    if ( src->attr == ast::EnumAttribute::Value ) {
-        if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
-            cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
-        } else {
-            auto baseType = src->instance->base->base;
-            cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+	if ( src->attr == ast::EnumAttribute::Value ) {
+		if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
+			cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
+		} else {
+			auto baseType = src->instance->base->base;
+			cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
 			if ( cost < Cost::infinity ) {
 				cost.incUnsafe();
 			}
-        }
-    } else { // ast::EnumAttribute::Posn
-        if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-		    cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
-		    if ( cost < Cost::unsafe ) cost.incSafe();
-	    } else {
-		    static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-		    cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-		    if ( cost < Cost::unsafe ) {
-			    cost.incSafe();
-		    }
-	    }
-    }
+		}
+	} else { // ast::EnumAttribute::Posn
+		if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
+			cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
+			if ( cost < Cost::unsafe ) cost.incSafe();
+		} else {
+			static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
+			cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+			if ( cost < Cost::unsafe ) {
+				cost.incSafe();
+			}
+		}
+	}
 }
 
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision 38093ae64b024ab4c59bfa2d4555f10ec56e103e)
+++ src/ResolvExpr/Unify.cc	(revision fc1a3e283512526d1ddc12898c7c5fa33f0ddeaf)
@@ -307,5 +307,5 @@
 				// type unification calls expression unification (mutual recursion)
 				if ( ! unify(array->dimension, array2->dimension,
-				    tenv, need, have, open, widen) ) return;
+					tenv, need, have, open, widen) ) return;
 			}
 
@@ -455,5 +455,5 @@
 			// check that the other type is compatible and named the same
 			auto otherInst = dynamic_cast< const XInstType * >( other );
-			if (otherInst && inst->name == otherInst->name) 
+			if (otherInst && inst->name == otherInst->name)
 				this->result = otherInst;
 			return otherInst;
@@ -542,8 +542,8 @@
 			// Lazy approach for now
 			if ( auto otherPos = dynamic_cast< const ast::EnumAttrType *>(type2) ) {
-			    if ( enumAttr->match(otherPos) ) {
-				    result = otherPos;
-			    }
-            }  
+				if ( enumAttr->match(otherPos) ) {
+					result = otherPos;
+				}
+			}
 		}