[Distributed] Remove commented out code and print statements

Author: xedin

include/swift/AST/StorageImpl.h

@@ -110,10 +110,6 @@ class AccessStrategy {
     /// separately performing a Read into a temporary variable followed by
     /// a Write access back into the storage.
     MaterializeToTemporary,
-
-//    /// The access is to a computed distributed property, and thus the
-//    /// get-accessor is a distributed thunk which may perform a remote call.
-//    DirectToDistributedThunkAccessor,
   };
 
 private:
@@ -153,10 +149,6 @@ class AccessStrategy {
     return { dispatched ? DispatchToAccessor : DirectToAccessor, accessor };
   }
 
-//  static AccessStrategy getDistributedGetAccessor(AccessorKind accessor) {
-//    assert(accessor == AccessorKind::Get);
-//    return { DirectToDistributedThunkAccessor, accessor };
-//  }
   static AccessStrategy getMaterializeToTemporary(AccessStrategy read,
                                                   AccessStrategy write) {
     return { read, write };

lib/AST/Decl.cpp

@@ -2151,17 +2151,6 @@ getDirectReadAccessStrategy(const AbstractStorageDecl *storage) {
   llvm_unreachable("bad impl kind");
 }
 
-//static AccessStrategy
-//getDirectToDistributedThunkAccessorStrategy(const AbstractStorageDecl *storage) {
-//  switch (storage->getReadImpl()) {
-//  case ReadImplKind::Get:
-//    return AccessStrategy::getDistributedGetAccessor(AccessorKind::Get);
-//  default:
-//    llvm_unreachable("bad impl kind for distributed property accessor");
-//  }
-//  llvm_unreachable("bad impl kind for distributed property accessor");
-//}
-
 static AccessStrategy
 getDirectWriteAccessStrategy(const AbstractStorageDecl *storage) {
   switch (storage->getWriteImpl()) {
@@ -2295,14 +2284,6 @@ AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
       if (shouldUseNativeDynamicDispatch())
         return getOpaqueAccessStrategy(this, accessKind, /*dispatch*/ false);
 
-//      if (auto var = dyn_cast<VarDecl>(this)) {
-//        if (var->isDistributed()) {
-//          fprintf(stderr, "[%s:%d] (%s) DIST STRATEGY!!\n", __FILE__, __LINE__, __FUNCTION__);
-//          var->dump();
-//          return getDirectToDistributedThunkAccessorStrategy(this);
-//        }
-//      }
-
       // If the storage is resilient from the given module and resilience
       // expansion, we cannot use direct access.
       //

lib/SILGen/SILGen.cpp

@@ -1764,9 +1764,6 @@ void SILGenModule::visitVarDecl(VarDecl *vd) {
   if (vd->hasStorage())
     addGlobalVariable(vd);
 
-  fprintf(stderr, "[%s:%d] (%s) VISIT VAR DECL\n", __FILE__, __LINE__, __FUNCTION__);
-  vd->dump();
-
   vd->visitEmittedAccessors([&](AccessorDecl *accessor) {
     emitFunction(accessor);
   });
@@ -1833,7 +1830,6 @@ SILGenModule::canStorageUseStoredKeyPathComponent(AbstractStorageDecl *decl,
   case AccessStrategy::DirectToAccessor:
   case AccessStrategy::DispatchToAccessor:
   case AccessStrategy::MaterializeToTemporary:
-//  case AccessStrategy::DirectToDistributedThunkAccessor:
     return false;
   }
   llvm_unreachable("unhandled strategy");

lib/SILGen/SILGenApply.cpp

@@ -1090,7 +1090,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     // If this is a direct reference to a vardecl, just emit its value directly.
     // Recursive references to callable declarations are allowed.
-    if (auto var = dyn_cast<VarDecl>(e->getDecl())) {
+    if (isa<VarDecl>(e->getDecl())) {
       visitExpr(e);
       return;
     }
@@ -1126,8 +1126,6 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     /// Some special handling may be necessary for thunks:
     if (callSite && callSite->shouldApplyDistributedThunk()) {
-      fprintf(stderr, "[%s:%d] (%s) SHOULD APPLY DIST THUNK\n", __FILE__, __LINE__, __FUNCTION__);
-
       if (auto distributedThunk = cast<AbstractFunctionDecl>(e->getDecl())->getDistributedThunk()) {
         constant = SILDeclRef(distributedThunk).asDistributed();
       }
@@ -5782,15 +5780,8 @@ RValue SILGenFunction::emitGetAccessor(SILLocation loc, SILDeclRef get,
   // Scope any further writeback just within this operation.
   FormalEvaluationScope writebackScope(*this);
 
-  auto constant = get;
-
-//  if (isDistributed) {
-//    get.dump();
-//    assert(false && "should use dist thunk");
-//  }
-
   Callee getter = emitSpecializedAccessorFunctionRef(
-      *this, loc, constant, substitutions, selfValue, isSuper, isDirectUse,
+      *this, loc, get, substitutions, selfValue, isSuper, isDirectUse,
       isDistributed, isOnSelfParameter);
   bool hasSelf = (bool)selfValue;
   CanAnyFunctionType accessType = getter.getSubstFormalType();

lib/SILGen/SILGenExpr.cpp

@@ -3504,23 +3504,6 @@ getIdForKeyPathComponentComputedProperty(SILGenModule &SGM,
     // stable identifier.
     return SGM.getFunction(getterRef, NotForDefinition);
   }
-//  case AccessStrategy::DirectToDistributedThunkAccessor: {
-//    assert(false && "dont need this");
-//    // Locate the distributed thunk for the getter of this property
-//    fprintf(stderr, "[%s:%d] (%s) CHECKING.... DirectToDistributedThunkAccessor\n", __FILE__, __LINE__, __FUNCTION__);
-//    auto representativeDecl = getRepresentativeAccessorForKeyPath(storage);
-//    assert(representativeDecl->isDistributed());
-//    fprintf(stderr, "[%s:%d] (%s) OK, representative is DIST\n", __FILE__, __LINE__, __FUNCTION__);
-//
-//    auto getterThunkRef = SILDeclRef(representativeDecl->getDistributedThunk(),
-//                                     SILDeclRef::Kind::Func,
-//                                     /*isForeign=*/false,
-//                                     /*isDistributed=*/true);
-//    fprintf(stderr, "[%s:%d] (%s) THUNK\n", __FILE__, __LINE__, __FUNCTION__);
-//    getterThunkRef.dump();
-//
-//    return SGM.getFunction(getterThunkRef, NotForDefinition);
-//  }
   case AccessStrategy::DispatchToAccessor: {
     // Identify the property by its vtable or wtable slot.
     return SGM.getAccessorDeclRef(getRepresentativeAccessorForKeyPath(storage));

lib/SILGen/SILGenLValue.cpp

@@ -1357,10 +1357,6 @@ namespace {
                                std::move(indices), isOnSelfParameter,
                                actorIso)
     {
-       if (isDistributedAccessor) {
-         fprintf(stderr, "[%s:%d] (%s) DIST ACCESSOR GOOD!\n", __FILE__, __LINE__, __FUNCTION__);
-         decl->dump();
-       }
       assert(getAccessorDecl()->isGetterOrSetter());
     }
 
@@ -1651,11 +1647,6 @@ namespace {
                ManagedValue base, SGFContext c) && override {
       assert(getAccessorDecl()->isGetter());
 
-      if (IsDistributedAccessor) {
-        fprintf(stderr, "[%s:%d] (%s) EMIT DIST GETTER\n", __FILE__, __LINE__, __FUNCTION__);
-        base.dump();
-      }
-
       SILDeclRef getter = Accessor;
       ExecutorBreadcrumb prevExecutor;
       RValue rvalue;

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -273,9 +273,6 @@ deriveBodyDistributed_thunk(AbstractFunctionDecl *thunk, void *context) {
     }
 
     auto returnLocalPropertyAccess = new (C) ReturnStmt(sloc, localPropertyAccess, implicit);
-
-    fprintf(stderr, "[%s:%d] (%s) LOCAL BRANCH\n", __FILE__, __LINE__, __FUNCTION__);
-    returnLocalPropertyAccess->dump();
     localBranchStmt =
         BraceStmt::create(C, sloc, {returnLocalPropertyAccess}, sloc, implicit);
   } else {

lib/Sema/TypeCheckConcurrency.cpp

@@ -2311,8 +2311,6 @@ namespace {
         // But computed distributed properties are okay,
         // and treated the same as a distributed func.
         if (var && var->isDistributed()) {
-          fprintf(stderr, "[%s:%d] (%s) HERE\n", __FILE__, __LINE__, __FUNCTION__);
-          var->dump();
           bool explicitlyThrowing = false;
           if (auto getter = var->getAccessor(swift::AccessorKind::Get)) {
             explicitlyThrowing = getter->hasThrows();
@@ -2363,25 +2361,18 @@ namespace {
       // is it an access to a property?
       if (isPropOrSubscript(decl)) {
         // Cannot reference properties or subscripts of distributed actors.
-        fprintf(stderr, "[%s:%d] (%s) prop\n", __FILE__, __LINE__, __FUNCTION__);
         if (isDistributed) {
-          fprintf(stderr, "[%s:%d] (%s) prop is dist\n", __FILE__, __LINE__, __FUNCTION__);
-
           bool setThrows = false;
           bool usesDistributedThunk = false;
           if (auto access = checkDistributedAccess(declLoc, decl, context)) {
             std::tie(setThrows, usesDistributedThunk) = *access;
           } else {
-            fprintf(stderr, "[%s:%d] (%s) prop is dist -> NOPE \n", __FILE__, __LINE__, __FUNCTION__);
             return AsyncMarkingResult::NotDistributed;
           }
 
           // distributed computed property access, mark it throws + async
           if (auto lookupExpr = dyn_cast_or_null<LookupExpr>(context)) {
             if (auto memberRef = dyn_cast<MemberRefExpr>(lookupExpr)) {
-              fprintf(stderr, "[%s:%d] (%s) SET DISTRIBUTED MEMBER REF\n", __FILE__, __LINE__, __FUNCTION__);
-              memberRef->dump();
-
               memberRef->setImplicitlyThrows(true);
               memberRef->setShouldApplyLookupDistributedThunk(true);
             } else {
@@ -2450,7 +2441,6 @@ namespace {
         if (isDistributed) {
           if (auto access = checkDistributedAccess(declLoc, decl, context)) {
             std::tie(setThrows, usesDistributedThunk) = *access;
-            fprintf(stderr, "[%s:%d] (%s) USE THUNK\n", __FILE__, __LINE__, __FUNCTION__);
           } else {
             return AsyncMarkingResult::NotDistributed;
           }