[clang][dataflow] Remove deprecated synonyms related to `RecordStorageLocation` and `RecordValue`

[mboehme]

Failing pre-merge checks look unrelated

clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h

 ///
 ///   refreshRecordValue(Loc, Env).setProperty("my_prop", MyPropValue);
 RecordValue &refreshRecordValue(RecordStorageLocation &Loc, Environment &Env);
 
 /// Associates a new `RecordValue` with `Expr` and returns the new value.
 /// See also documentation for the overload above.
 RecordValue &refreshRecordValue(const Expr &Expr, Environment &Env);
 
-/// Deprecated synonym for `refreshRecordValue()`.
-inline RecordValue &refreshStructValue(RecordStorageLocation &Loc,
-                                       Environment &Env) {
-  return refreshRecordValue(Loc, Env);
-}
-inline RecordValue &refreshStructValue(const Expr &Expr, Environment &Env) {
-  return refreshRecordValue(Expr, Env);
-}
-
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_DATAFLOWENVIRONMENT_H

clang/include/clang/Analysis/FlowSensitive/StorageLocation.h

 ///
 /// Each storage location holds a value. The mapping from storage locations to
 /// values is stored in the environment.
 class StorageLocation {
 public:
   enum class Kind {
     Scalar,
     Record,
-    // Deprecated synonym for `Record`
-    Aggregate = Record,
   };
 
   StorageLocation(Kind LocKind, QualType Type) : LocKind(LocKind), Type(Type) {
     assert(Type.isNull() || !Type->isReferenceType());
   }
 
   // Non-copyable because addresses of storage locations are used as their
   // identities throughout framework and user code. The framework is responsible
public:
   llvm::iterator_range<FieldToLoc::const_iterator> children() const {
     return {Children.begin(), Children.end()};
   }
 
 private:
   FieldToLoc Children;
 };
 
-/// Deprecated synonym for `RecordStorageLocation`.
-using AggregateStorageLocation = RecordStorageLocation;
-
 } // namespace dataflow
 } // namespace clang
 
 #undef DEBUG_TYPE
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_STORAGELOCATION_H

clang/include/clang/Analysis/FlowSensitive/Value.h

 /// Don't use `Value` instances by value. All `Value` instances are allocated
 /// and owned by `DataflowAnalysisContext`.
 class Value {
 public:
   enum class Kind {
     Integer,
     Pointer,
     Record,
-    // Deprecated synonym for `Record`
-    Struct = Record,
 
     // TODO: Top values should not be need to be type-specific.
     TopBool,
     AtomicBool,
     FormulaBool,
   };
 
   explicit Value(Kind ValKind) : ValKind(ValKind) {}
public:
 
   static bool classof(const Value *Val) {
     return Val->getKind() == Kind::Record;
   }
 
   /// Returns the storage location that this `RecordValue` is associated with.
   RecordStorageLocation &getLoc() const { return Loc; }
 
-  /// Deprecated synonym for `getLoc()`.
-  RecordStorageLocation &getAggregateLoc() const { return Loc; }
-
   /// Convenience function that returns the child storage location for `Field`.
   /// See also the documentation for `RecordStorageLocation::getChild()`.
   StorageLocation *getChild(const ValueDecl &Field) const {
     return Loc.getChild(Field);
   }
 
 private:
   RecordStorageLocation &Loc;
 };
 
-/// Deprecated synonym for `RecordValue`.
-using StructValue = RecordValue;
-
 raw_ostream &operator<<(raw_ostream &OS, const Value &Val);
 
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_VALUE_H