Fix compilation on MSVC, NFC

[etherzhhb]

Summary

Not sure if this is the right fix

[grosser]

This seems to be the right solution. Thanks for figuring this out!

polly/trunk/include/polly/ScopInfo.h

public:
   /// @param ElementType    The type of the elements stored in the array.
   /// @param IslCtx         The isl context used to create the base pointer id.
   /// @param DimensionSizes A vector containing the size of each dimension.
   /// @param Kind           The kind of the array object.
   /// @param DL             The data layout of the module.
   /// @param S              The scop this array object belongs to.
   /// @param BaseName       The optional name of this memory reference.
   ScopArrayInfo(Value *BasePtr, Type *ElementType, isl_ctx *IslCtx,
-                ArrayRef<const SCEV *> DimensionSizes, enum MemoryKind Kind,
+                ArrayRef<const SCEV *> DimensionSizes, MemoryKind Kind,
                 const DataLayout &DL, Scop *S, const char *BaseName = nullptr);
 
   ///  Update the element type of the ScopArrayInfo object.
   ///
   ///  Memory accesses referencing this ScopArrayInfo object may use
   ///  different element sizes. This function ensures the canonical element type
   ///  stored is small enough to model accesses to the current element type as
   ///  well as to @p NewElementType.
public:
 
   /// Get the name of this memory reference.
   std::string getName() const;
 
   /// Return the isl id for the base pointer.
   __isl_give isl_id *getBasePtrId() const;
 
   /// Return what kind of memory this represents.
-  enum MemoryKind getKind() const { return Kind; }
+  MemoryKind getKind() const { return Kind; }
 
   /// Is this array info modeling an llvm::Value?
   bool isValueKind() const { return Kind == MemoryKind::Value; }
 
   /// Is this array info modeling special PHI node memory?
   ///
   /// During code generation of PHI nodes, there is a need for two kinds of
   /// virtual storage. The normal one as it is used for all scalar dependences,
private:
   SmallVector<const SCEV *, 4> DimensionSizes;
 
   /// The sizes of each dimension as isl_pw_aff.
   SmallVector<isl_pw_aff *, 4> DimensionSizesPw;
 
   /// The type of this scop array info object.
   ///
   /// We distinguish between SCALAR, PHI and ARRAY objects.
-  enum MemoryKind Kind;
+  MemoryKind Kind;
 
   /// The data layout of the module.
   const DataLayout &DL;
 
   /// The scop this SAI object belongs to.
   Scop &S;
 };
 
private:
   DenseMap<BasicBlock *, isl_set *> DomainMap;
 
   /// Constraints on parameters.
   isl_set *Context;
 
   /// The affinator used to translate SCEVs to isl expressions.
   SCEVAffinator Affinator;
 
-  typedef std::map<std::pair<AssertingVH<const Value>, enum MemoryKind>,
+  typedef std::map<std::pair<AssertingVH<const Value>, MemoryKind>,
                    std::unique_ptr<ScopArrayInfo>>
       ArrayInfoMapTy;
 
   typedef StringMap<std::unique_ptr<ScopArrayInfo>> ArrayNameMapTy;
 
   typedef SetVector<ScopArrayInfo *> ArrayInfoSetTy;
 
   /// A map to remember ScopArrayInfo objects for all base pointers.

polly/trunk/lib/Analysis/ScopInfo.cpp

static const ScopArrayInfo *identifyBasePtrOriginSAI(Scop *S, Value *BasePtr) {
   if (!OriginBaseSCEVUnknown)
     return nullptr;
 
   return S->getScopArrayInfo(OriginBaseSCEVUnknown->getValue(),
                              MemoryKind::Array);
 }
 
 ScopArrayInfo::ScopArrayInfo(Value *BasePtr, Type *ElementType, isl_ctx *Ctx,
-                             ArrayRef<const SCEV *> Sizes, enum MemoryKind Kind,
+                             ArrayRef<const SCEV *> Sizes, MemoryKind Kind,
                              const DataLayout &DL, Scop *S,
                              const char *BaseName)
     : BasePtr(BasePtr), ElementType(ElementType), Kind(Kind), DL(DL), S(*S) {
   std::string BasePtrName =
       BaseName ? BaseName
                : getIslCompatibleName("MemRef_", BasePtr,
                                       Kind == MemoryKind::PHI ? "__phi" : "");
   Id = isl_id_alloc(Ctx, BasePtrName.c_str(), this);