Cleanup: Rename: Static Override -> Library Override.

Better to make internal code naming match official/UI naming to some
extent, this will reduce confusion in the future.

This is 'breaking' scripts and files that would use that feature, but
since it is not yet officially supported nor exposed in 2.80, as far
as that release is concerned, it is effectively
a 'no functional changes' commit.

12 files changed, 215 insertions, 211 deletions

diff --git a/source/blender/blenkernel/BKE_library_override.h b/source/blender/blenkernel/BKE_library_override.h
index bdecff87cf1..5440b0ebe63 100644
--- a/source/blender/blenkernel/BKE_library_override.h
+++ b/source/blender/blenkernel/BKE_library_override.h
@@ -25,39 +25,39 @@
  */
 
 struct ID;
-struct IDOverrideStatic;
-struct IDOverrideStaticProperty;
-struct IDOverrideStaticPropertyOperation;
+struct IDOverrideLibrary;
+struct IDOverrideLibraryProperty;
+struct IDOverrideLibraryPropertyOperation;
 struct Main;
 
-void BKE_override_static_enable(const bool do_enable);
-bool BKE_override_static_is_enabled(void);
+void BKE_override_library_enable(const bool do_enable);
+bool BKE_override_library_is_enabled(void);
 
-struct IDOverrideStatic *BKE_override_static_init(struct ID *local_id, struct ID *reference_id);
-void BKE_override_static_copy(struct ID *dst_id, const struct ID *src_id);
-void BKE_override_static_clear(struct IDOverrideStatic *override);
-void BKE_override_static_free(struct IDOverrideStatic **override);
+struct IDOverrideLibrary *BKE_override_library_init(struct ID *local_id, struct ID *reference_id);
+void BKE_override_library_copy(struct ID *dst_id, const struct ID *src_id);
+void BKE_override_library_clear(struct IDOverrideLibrary *override);
+void BKE_override_library_free(struct IDOverrideLibrary **override);
 
-struct ID *BKE_override_static_create_from_id(struct Main *bmain, struct ID *reference_id);
-bool BKE_override_static_create_from_tag(struct Main *bmain);
+struct ID *BKE_override_library_create_from_id(struct Main *bmain, struct ID *reference_id);
+bool BKE_override_library_create_from_tag(struct Main *bmain);
 
-struct IDOverrideStaticProperty *BKE_override_static_property_find(
-    struct IDOverrideStatic *override, const char *rna_path);
-struct IDOverrideStaticProperty *BKE_override_static_property_get(
-    struct IDOverrideStatic *override, const char *rna_path, bool *r_created);
-void BKE_override_static_property_delete(struct IDOverrideStatic *override,
-                                         struct IDOverrideStaticProperty *override_property);
+struct IDOverrideLibraryProperty *BKE_override_library_property_find(
+    struct IDOverrideLibrary *override, const char *rna_path);
+struct IDOverrideLibraryProperty *BKE_override_library_property_get(
+    struct IDOverrideLibrary *override, const char *rna_path, bool *r_created);
+void BKE_override_library_property_delete(struct IDOverrideLibrary *override,
+                                          struct IDOverrideLibraryProperty *override_property);
 
-struct IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
-    struct IDOverrideStaticProperty *override_property,
+struct IDOverrideLibraryPropertyOperation *BKE_override_library_property_operation_find(
+    struct IDOverrideLibraryProperty *override_property,
     const char *subitem_refname,
     const char *subitem_locname,
     const int subitem_refindex,
     const int subitem_locindex,
     const bool strict,
     bool *r_strict);
-struct IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
-    struct IDOverrideStaticProperty *override_property,
+struct IDOverrideLibraryPropertyOperation *BKE_override_library_property_operation_get(
+    struct IDOverrideLibraryProperty *override_property,
     const short operation,
     const char *subitem_refname,
     const char *subitem_locname,
@@ -66,32 +66,32 @@ struct IDOverrideStaticPropertyOperation *BKE_override_static_property_operation
     const bool strict,
     bool *r_strict,
     bool *r_created);
-void BKE_override_static_property_operation_delete(
-    struct IDOverrideStaticProperty *override_property,
-    struct IDOverrideStaticPropertyOperation *override_property_operation);
+void BKE_override_library_property_operation_delete(
+    struct IDOverrideLibraryProperty *override_property,
+    struct IDOverrideLibraryPropertyOperation *override_property_operation);
 
-bool BKE_override_static_status_check_local(struct Main *bmain, struct ID *local);
-bool BKE_override_static_status_check_reference(struct Main *bmain, struct ID *local);
+bool BKE_override_library_status_check_local(struct Main *bmain, struct ID *local);
+bool BKE_override_library_status_check_reference(struct Main *bmain, struct ID *local);
 
-bool BKE_override_static_operations_create(struct Main *bmain,
-                                           struct ID *local,
-                                           const bool force_auto);
-void BKE_main_override_static_operations_create(struct Main *bmain, const bool force_auto);
+bool BKE_override_library_operations_create(struct Main *bmain,
+                                            struct ID *local,
+                                            const bool force_auto);
+void BKE_main_override_library_operations_create(struct Main *bmain, const bool force_auto);
 
-void BKE_override_static_update(struct Main *bmain, struct ID *local);
-void BKE_main_override_static_update(struct Main *bmain);
+void BKE_override_library_update(struct Main *bmain, struct ID *local);
+void BKE_main_override_library_update(struct Main *bmain);
 
 /* Storage (.blend file writing) part. */
 
 /* For now, we just use a temp main list. */
-typedef struct Main OverrideStaticStorage;
+typedef struct Main OverrideLibraryStorage;
 
-OverrideStaticStorage *BKE_override_static_operations_store_initialize(void);
-struct ID *BKE_override_static_operations_store_start(struct Main *bmain,
-                                                      OverrideStaticStorage *override_storage,
-                                                      struct ID *local);
-void BKE_override_static_operations_store_end(OverrideStaticStorage *override_storage,
-                                              struct ID *local);
-void BKE_override_static_operations_store_finalize(OverrideStaticStorage *override_storage);
+OverrideLibraryStorage *BKE_override_library_operations_store_initialize(void);
+struct ID *BKE_override_library_operations_store_start(struct Main *bmain,
+                                                       OverrideLibraryStorage *override_storage,
+                                                       struct ID *local);
+void BKE_override_library_operations_store_end(OverrideLibraryStorage *override_storage,
+                                               struct ID *local);
+void BKE_override_library_operations_store_finalize(OverrideLibraryStorage *override_storage);
 
 #endif /* __BKE_LIBRARY_OVERRIDE_H__ */
diff --git a/source/blender/blenkernel/BKE_library_query.h b/source/blender/blenkernel/BKE_library_query.h
index 94e7830aabe..4f74b2b5a6b 100644
--- a/source/blender/blenkernel/BKE_library_query.h
+++ b/source/blender/blenkernel/BKE_library_query.h
@@ -51,8 +51,8 @@ enum {
    * How to handle that kind of cases totally depends on what caller code is doing... */
   IDWALK_CB_LOOPBACK = (1 << 4),
 
-  /** That ID is used as static override's reference by its owner. */
-  IDWALK_CB_STATIC_OVERRIDE_REFERENCE = (1 << 5),
+  /** That ID is used as library override's reference by its owner. */
+  IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE = (1 << 5),
 
   /**
    * Adjusts #ID.us reference-count.
diff --git a/source/blender/blenkernel/BKE_library_remap.h b/source/blender/blenkernel/BKE_library_remap.h
index 41ac8c8c8e6..d51bc5c2bce 100644
--- a/source/blender/blenkernel/BKE_library_remap.h
+++ b/source/blender/blenkernel/BKE_library_remap.h
@@ -61,8 +61,8 @@ enum {
    * is also performed. Usual nightmare...
    */
   ID_REMAP_NO_INDIRECT_PROXY_DATA_USAGE = 1 << 4,
-  /** Do not remap static override pointers. */
-  ID_REMAP_SKIP_STATIC_OVERRIDE = 1 << 5,
+  /** Do not remap library override pointers. */
+  ID_REMAP_SKIP_OVERRIDE_LIBRARY = 1 << 5,
 };
 
 /* Note: Requiring new_id to be non-null, this *may* not be the case ultimately,
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index ee9041c5c18..4ae9b106e85 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -5100,7 +5100,7 @@ static bConstraint *add_new_constraint_internal(const char *name, short type)
 
   /* Set up a generic constraint data-block. */
   con->type = type;
-  con->flag |= CONSTRAINT_EXPAND | CONSTRAINT_STATICOVERRIDE_LOCAL;
+  con->flag |= CONSTRAINT_EXPAND | CONSTRAINT_OVERRIDE_LIBRARY_LOCAL;
   con->enforce = 1.0f;
 
   /* Determine a basic name, and info */
diff --git a/source/blender/blenkernel/intern/gpencil_modifier.c b/source/blender/blenkernel/intern/gpencil_modifier.c
index c8a45a92758..2b27854ba82 100644
--- a/source/blender/blenkernel/intern/gpencil_modifier.c
+++ b/source/blender/blenkernel/intern/gpencil_modifier.c
@@ -551,7 +551,7 @@ GpencilModifierData *BKE_gpencil_modifier_new(int type)
   md->type = type;
   md->mode = eGpencilModifierMode_Realtime | eGpencilModifierMode_Render |
              eGpencilModifierMode_Expanded;
-  md->flag = eGpencilModifierFlag_StaticOverride_Local;
+  md->flag = eGpencilModifierFlag_OverrideLibrary_Local;
 
   if (mti->flags & eGpencilModifierTypeFlag_EnableInEditmode) {
     md->mode |= eGpencilModifierMode_Editmode;
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index 2a32c215d2a..5e54344c80e 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -2281,7 +2281,7 @@ void BKE_id_full_name_get(char name[MAX_ID_FULL_NAME], const ID *id)
  */
 void BKE_id_full_name_ui_prefix_get(char name[MAX_ID_FULL_NAME_UI], const ID *id)
 {
-  name[0] = id->lib ? (ID_MISSING(id) ? 'M' : 'L') : ID_IS_STATIC_OVERRIDE(id) ? 'O' : ' ';
+  name[0] = id->lib ? (ID_MISSING(id) ? 'M' : 'L') : ID_IS_OVERRIDE_LIBRARY(id) ? 'O' : ' ';
   name[1] = (id->flag & LIB_FAKEUSER) ? 'F' : ((id->us == 0) ? '0' : ' ');
   name[2] = ' ';
 
diff --git a/source/blender/blenkernel/intern/library_override.c b/source/blender/blenkernel/intern/library_override.c
index 231e0b8ee60..caa50cd0ebf 100644
--- a/source/blender/blenkernel/intern/library_override.c
+++ b/source/blender/blenkernel/intern/library_override.c
@@ -47,108 +47,108 @@
 
 #define OVERRIDE_AUTO_CHECK_DELAY 0.2 /* 200ms between auto-override checks. */
 
-static void bke_override_property_copy(IDOverrideStaticProperty *op_dst,
-                                       IDOverrideStaticProperty *op_src);
-static void bke_override_property_operation_copy(IDOverrideStaticPropertyOperation *opop_dst,
-                                                 IDOverrideStaticPropertyOperation *opop_src);
+static void bke_override_property_copy(IDOverrideLibraryProperty *op_dst,
+                                       IDOverrideLibraryProperty *op_src);
+static void bke_override_property_operation_copy(IDOverrideLibraryPropertyOperation *opop_dst,
+                                                 IDOverrideLibraryPropertyOperation *opop_src);
 
-static void bke_override_property_clear(IDOverrideStaticProperty *op);
-static void bke_override_property_operation_clear(IDOverrideStaticPropertyOperation *opop);
+static void bke_override_property_clear(IDOverrideLibraryProperty *op);
+static void bke_override_property_operation_clear(IDOverrideLibraryPropertyOperation *opop);
 
-/* Temp, for until static override is ready and tested enough to go 'public',
+/* Temp, for until library override is ready and tested enough to go 'public',
  * we hide it by default in UI and such. */
-static bool _override_static_enabled = false;
+static bool _override_library_enabled = false;
 
-void BKE_override_static_enable(const bool do_enable)
+void BKE_override_library_enable(const bool do_enable)
 {
-  _override_static_enabled = do_enable;
+  _override_library_enabled = do_enable;
 }
 
-bool BKE_override_static_is_enabled()
+bool BKE_override_library_is_enabled()
 {
-  return _override_static_enabled;
+  return _override_library_enabled;
 }
 
 /** Initialize empty overriding of \a reference_id by \a local_id. */
-IDOverrideStatic *BKE_override_static_init(ID *local_id, ID *reference_id)
+IDOverrideLibrary *BKE_override_library_init(ID *local_id, ID *reference_id)
 {
   /* If reference_id is NULL, we are creating an override template for purely local data.
    * Else, reference *must* be linked data. */
   BLI_assert(reference_id == NULL || reference_id->lib != NULL);
-  BLI_assert(local_id->override_static == NULL);
+  BLI_assert(local_id->override_library == NULL);
 
   ID *ancestor_id;
-  for (ancestor_id = reference_id; ancestor_id != NULL && ancestor_id->override_static != NULL &&
-                                   ancestor_id->override_static->reference != NULL;
-       ancestor_id = ancestor_id->override_static->reference) {
+  for (ancestor_id = reference_id; ancestor_id != NULL && ancestor_id->override_library != NULL &&
+                                   ancestor_id->override_library->reference != NULL;
+       ancestor_id = ancestor_id->override_library->reference) {
     /* pass */
   }
 
-  if (ancestor_id != NULL && ancestor_id->override_static != NULL) {
+  if (ancestor_id != NULL && ancestor_id->override_library != NULL) {
     /* Original ID has a template, use it! */
-    BKE_override_static_copy(local_id, ancestor_id);
-    if (local_id->override_static->reference != reference_id) {
-      id_us_min(local_id->override_static->reference);
-      local_id->override_static->reference = reference_id;
-      id_us_plus(local_id->override_static->reference);
+    BKE_override_library_copy(local_id, ancestor_id);
+    if (local_id->override_library->reference != reference_id) {
+      id_us_min(local_id->override_library->reference);
+      local_id->override_library->reference = reference_id;
+      id_us_plus(local_id->override_library->reference);
     }
-    return local_id->override_static;
+    return local_id->override_library;
   }
 
   /* Else, generate new empty override. */
-  local_id->override_static = MEM_callocN(sizeof(*local_id->override_static), __func__);
-  local_id->override_static->reference = reference_id;
-  id_us_plus(local_id->override_static->reference);
-  local_id->tag &= ~LIB_TAG_OVERRIDESTATIC_REFOK;
+  local_id->override_library = MEM_callocN(sizeof(*local_id->override_library), __func__);
+  local_id->override_library->reference = reference_id;
+  id_us_plus(local_id->override_library->reference);
+  local_id->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_REFOK;
   /* TODO do we want to add tag or flag to referee to mark it as such? */
-  return local_id->override_static;
+  return local_id->override_library;
 }
 
 /** Deep copy of a whole override from \a src_id to \a dst_id. */
-void BKE_override_static_copy(ID *dst_id, const ID *src_id)
+void BKE_override_library_copy(ID *dst_id, const ID *src_id)
 {
-  BLI_assert(src_id->override_static != NULL);
+  BLI_assert(src_id->override_library != NULL);
 
-  if (dst_id->override_static != NULL) {
-    if (src_id->override_static == NULL) {
-      BKE_override_static_free(&dst_id->override_static);
+  if (dst_id->override_library != NULL) {
+    if (src_id->override_library == NULL) {
+      BKE_override_library_free(&dst_id->override_library);
       return;
     }
     else {
-      BKE_override_static_clear(dst_id->override_static);
+      BKE_override_library_clear(dst_id->override_library);
     }
   }
-  else if (src_id->override_static == NULL) {
+  else if (src_id->override_library == NULL) {
     return;
   }
   else {
-    BKE_override_static_init(dst_id, NULL);
+    BKE_override_library_init(dst_id, NULL);
   }
 
   /* Source is already overriding data, we copy it but reuse its reference for dest ID.
    * otherwise, source is only an override template, it then becomes reference of dest ID. */
-  dst_id->override_static->reference = src_id->override_static->reference ?
-                                           src_id->override_static->reference :
-                                           (ID *)src_id;
-  id_us_plus(dst_id->override_static->reference);
-
-  BLI_duplicatelist(&dst_id->override_static->properties, &src_id->override_static->properties);
-  for (IDOverrideStaticProperty *op_dst = dst_id->override_static->properties.first,
-                                *op_src = src_id->override_static->properties.first;
+  dst_id->override_library->reference = src_id->override_library->reference ?
+                                            src_id->override_library->reference :
+                                            (ID *)src_id;
+  id_us_plus(dst_id->override_library->reference);
+
+  BLI_duplicatelist(&dst_id->override_library->properties, &src_id->override_library->properties);
+  for (IDOverrideLibraryProperty *op_dst = dst_id->override_library->properties.first,
+                                 *op_src = src_id->override_library->properties.first;
        op_dst;
        op_dst = op_dst->next, op_src = op_src->next) {
     bke_override_property_copy(op_dst, op_src);
   }
 
-  dst_id->tag &= ~LIB_TAG_OVERRIDESTATIC_REFOK;
+  dst_id->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_REFOK;
 }
 
 /** Clear any overriding data from given \a override. */
-void BKE_override_static_clear(IDOverrideStatic *override)
+void BKE_override_library_clear(IDOverrideLibrary *override)
 {
   BLI_assert(override != NULL);
 
-  for (IDOverrideStaticProperty *op = override->properties.first; op; op = op->next) {
+  for (IDOverrideLibraryProperty *op = override->properties.first; op; op = op->next) {
     bke_override_property_clear(op);
   }
   BLI_freelistN(&override->properties);
@@ -158,16 +158,16 @@ void BKE_override_static_clear(IDOverrideStatic *override)
 }
 
 /** Free given \a override. */
-void BKE_override_static_free(struct IDOverrideStatic **override)
+void BKE_override_library_free(struct IDOverrideLibrary **override)
 {
   BLI_assert(*override != NULL);
 
-  BKE_override_static_clear(*override);
+  BKE_override_library_clear(*override);
   MEM_freeN(*override);
   *override = NULL;
 }
 
-static ID *override_static_create_from(Main *bmain, ID *reference_id)
+static ID *override_library_create_from(Main *bmain, ID *reference_id)
 {
   ID *local_id;
 
@@ -176,24 +176,26 @@ static ID *override_static_create_from(Main *bmain, ID *reference_id)
   }
   id_us_min(local_id);
 
-  BKE_override_static_init(local_id, reference_id);
-  local_id->override_static->flag |= STATICOVERRIDE_AUTO;
+  BKE_override_library_init(local_id, reference_id);
+  local_id->override_library->flag |= OVERRIDE_LIBRARY_AUTO;
 
   return local_id;
 }
 
 /** Create an overridden local copy of linked reference. */
-ID *BKE_override_static_create_from_id(Main *bmain, ID *reference_id)
+ID *BKE_override_library_create_from_id(Main *bmain, ID *reference_id)
 {
   BLI_assert(reference_id != NULL);
   BLI_assert(reference_id->lib != NULL);
 
-  ID *local_id = override_static_create_from(bmain, reference_id);
+  ID *local_id = override_library_create_from(bmain, reference_id);
 
   /* Remapping, we obviously only want to affect local data
    * (and not our own reference pointer to overridden ID). */
-  BKE_libblock_remap(
-      bmain, reference_id, local_id, ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_STATIC_OVERRIDE);
+  BKE_libblock_remap(bmain,
+                     reference_id,
+                     local_id,
+                     ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_OVERRIDE_LIBRARY);
 
   return local_id;
 }
@@ -205,14 +207,14 @@ ID *BKE_override_static_create_from_id(Main *bmain, ID *reference_id)
  *
  * \return \a true on success, \a false otherwise.
  */
-bool BKE_override_static_create_from_tag(Main *bmain)
+bool BKE_override_library_create_from_tag(Main *bmain)
 {
   ID *reference_id;
   bool ret = true;
 
   FOREACH_MAIN_ID_BEGIN (bmain, reference_id) {
     if ((reference_id->tag & LIB_TAG_DOIT) != 0 && reference_id->lib != NULL) {
-      if ((reference_id->newid = override_static_create_from(bmain, reference_id)) == NULL) {
+      if ((reference_id->newid = override_library_create_from(bmain, reference_id)) == NULL) {
         ret = false;
       }
     }
@@ -226,7 +228,7 @@ bool BKE_override_static_create_from_tag(Main *bmain)
       BKE_libblock_remap(bmain,
                          reference_id,
                          local_id,
-                         ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_STATIC_OVERRIDE);
+                         ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_OVERRIDE_LIBRARY);
     }
   }
   FOREACH_MAIN_ID_END;
@@ -237,26 +239,26 @@ bool BKE_override_static_create_from_tag(Main *bmain)
 /**
  * Find override property from given RNA path, if it exists.
  */
-IDOverrideStaticProperty *BKE_override_static_property_find(IDOverrideStatic *override,
-                                                            const char *rna_path)
+IDOverrideLibraryProperty *BKE_override_library_property_find(IDOverrideLibrary *override,
+                                                              const char *rna_path)
 {
   /* XXX TODO we'll most likely want a runtime ghash to store that mapping at some point. */
   return BLI_findstring_ptr(
-      &override->properties, rna_path, offsetof(IDOverrideStaticProperty, rna_path));
+      &override->properties, rna_path, offsetof(IDOverrideLibraryProperty, rna_path));
 }
 
 /**
  * Find override property from given RNA path, or create it if it does not exist.
  */
-IDOverrideStaticProperty *BKE_override_static_property_get(IDOverrideStatic *override,
-                                                           const char *rna_path,
-                                                           bool *r_created)
+IDOverrideLibraryProperty *BKE_override_library_property_get(IDOverrideLibrary *override,
+                                                             const char *rna_path,
+                                                             bool *r_created)
 {
   /* XXX TODO we'll most likely want a runtime ghash to store that mapping at some point. */
-  IDOverrideStaticProperty *op = BKE_override_static_property_find(override, rna_path);
+  IDOverrideLibraryProperty *op = BKE_override_library_property_find(override, rna_path);
 
   if (op == NULL) {
-    op = MEM_callocN(sizeof(IDOverrideStaticProperty), __func__);
+    op = MEM_callocN(sizeof(IDOverrideLibraryProperty), __func__);
     op->rna_path = BLI_strdup(rna_path);
     BLI_addtail(&override->properties, op);
 
@@ -271,26 +273,27 @@ IDOverrideStaticProperty *BKE_override_static_property_get(IDOverrideStatic *ove
   return op;
 }
 
-void bke_override_property_copy(IDOverrideStaticProperty *op_dst, IDOverrideStaticProperty *op_src)
+void bke_override_property_copy(IDOverrideLibraryProperty *op_dst,
+                                IDOverrideLibraryProperty *op_src)
 {
   op_dst->rna_path = BLI_strdup(op_src->rna_path);
   BLI_duplicatelist(&op_dst->operations, &op_src->operations);
 
-  for (IDOverrideStaticPropertyOperation *opop_dst = op_dst->operations.first,
-                                         *opop_src = op_src->operations.first;
+  for (IDOverrideLibraryPropertyOperation *opop_dst = op_dst->operations.first,
+                                          *opop_src = op_src->operations.first;
        opop_dst;
        opop_dst = opop_dst->next, opop_src = opop_src->next) {
     bke_override_property_operation_copy(opop_dst, opop_src);
   }
 }
 
-void bke_override_property_clear(IDOverrideStaticProperty *op)
+void bke_override_property_clear(IDOverrideLibraryProperty *op)
 {
   BLI_assert(op->rna_path != NULL);
 
   MEM_freeN(op->rna_path);
 
-  for (IDOverrideStaticPropertyOperation *opop = op->operations.first; opop; opop = opop->next) {
+  for (IDOverrideLibraryPropertyOperation *opop = op->operations.first; opop; opop = opop->next) {
     bke_override_property_operation_clear(opop);
   }
   BLI_freelistN(&op->operations);
@@ -299,8 +302,8 @@ void bke_override_property_clear(IDOverrideStaticProperty *op)
 /**
  * Remove and free given \a override_property from given ID \a override.
  */
-void BKE_override_static_property_delete(IDOverrideStatic *override,
-                                         IDOverrideStaticProperty *override_property)
+void BKE_override_library_property_delete(IDOverrideLibrary *override,
+                                          IDOverrideLibraryProperty *override_property)
 {
   bke_override_property_clear(override_property);
   BLI_freelinkN(&override->properties, override_property);
@@ -309,8 +312,8 @@ void BKE_override_static_property_delete(IDOverrideStatic *override,
 /**
  * Find override property operation from given sub-item(s), if it exists.
  */
-IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
-    IDOverrideStaticProperty *override_property,
+IDOverrideLibraryPropertyOperation *BKE_override_library_property_operation_find(
+    IDOverrideLibraryProperty *override_property,
     const char *subitem_refname,
     const char *subitem_locname,
     const int subitem_refindex,
@@ -318,7 +321,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
     const bool strict,
     bool *r_strict)
 {
-  IDOverrideStaticPropertyOperation *opop;
+  IDOverrideLibraryPropertyOperation *opop;
   const int subitem_defindex = -1;
 
   if (r_strict) {
@@ -328,7 +331,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
   if (subitem_locname != NULL) {
     opop = BLI_findstring_ptr(&override_property->operations,
                               subitem_locname,
-                              offsetof(IDOverrideStaticPropertyOperation, subitem_local_name));
+                              offsetof(IDOverrideLibraryPropertyOperation, subitem_local_name));
 
     if (opop == NULL) {
       return NULL;
@@ -344,9 +347,10 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
   }
 
   if (subitem_refname != NULL) {
-    opop = BLI_findstring_ptr(&override_property->operations,
-                              subitem_refname,
-                              offsetof(IDOverrideStaticPropertyOperation, subitem_reference_name));
+    opop = BLI_findstring_ptr(
+        &override_property->operations,
+        subitem_refname,
+        offsetof(IDOverrideLibraryPropertyOperation, subitem_reference_name));
 
     if (opop == NULL) {
       return NULL;
@@ -365,7 +369,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
            &override_property->operations,
            &subitem_locindex,
            sizeof(subitem_locindex),
-           offsetof(IDOverrideStaticPropertyOperation, subitem_local_index)))) {
+           offsetof(IDOverrideLibraryPropertyOperation, subitem_local_index)))) {
     return ELEM(subitem_refindex, -1, opop->subitem_reference_index) ? opop : NULL;
   }
 
@@ -373,7 +377,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
            &override_property->operations,
            &subitem_refindex,
            sizeof(subitem_refindex),
-           offsetof(IDOverrideStaticPropertyOperation, subitem_reference_index)))) {
+           offsetof(IDOverrideLibraryPropertyOperation, subitem_reference_index)))) {
     return ELEM(subitem_locindex, -1, opop->subitem_local_index) ? opop : NULL;
   }
 
@@ -383,7 +387,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
            &override_property->operations,
            &subitem_defindex,
            sizeof(subitem_defindex),
-           offsetof(IDOverrideStaticPropertyOperation, subitem_local_index)))) {
+           offsetof(IDOverrideLibraryPropertyOperation, subitem_local_index)))) {
     if (r_strict) {
       *r_strict = false;
     }
@@ -396,8 +400,8 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
 /**
  * Find override property operation from given sub-item(s), or create it if it does not exist.
  */
-IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
-    IDOverrideStaticProperty *override_property,
+IDOverrideLibraryPropertyOperation *BKE_override_library_property_operation_get(
+    IDOverrideLibraryProperty *override_property,
     const short operation,
     const char *subitem_refname,
     const char *subitem_locname,
@@ -407,7 +411,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
     bool *r_strict,
     bool *r_created)
 {
-  IDOverrideStaticPropertyOperation *opop = BKE_override_static_property_operation_find(
+  IDOverrideLibraryPropertyOperation *opop = BKE_override_library_property_operation_find(
       override_property,
       subitem_refname,
       subitem_locname,
@@ -417,7 +421,7 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
       r_strict);
 
   if (opop == NULL) {
-    opop = MEM_callocN(sizeof(IDOverrideStaticPropertyOperation), __func__);
+    opop = MEM_callocN(sizeof(IDOverrideLibraryPropertyOperation), __func__);
     opop->operation = operation;
     if (subitem_locname) {
       opop->subitem_local_name = BLI_strdup(subitem_locname);
@@ -441,8 +445,8 @@ IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
   return opop;
 }
 
-void bke_override_property_operation_copy(IDOverrideStaticPropertyOperation *opop_dst,
-                                          IDOverrideStaticPropertyOperation *opop_src)
+void bke_override_property_operation_copy(IDOverrideLibraryPropertyOperation *opop_dst,
+                                          IDOverrideLibraryPropertyOperation *opop_src)
 {
   if (opop_src->subitem_reference_name) {
     opop_dst->subitem_reference_name = BLI_strdup(opop_src->subitem_reference_name);
@@ -452,7 +456,7 @@ void bke_override_property_operation_copy(IDOverrideStaticPropertyOperation *opo
   }
 }
 
-void bke_override_property_operation_clear(IDOverrideStaticPropertyOperation *opop)
+void bke_override_property_operation_clear(IDOverrideLibraryPropertyOperation *opop)
 {
   if (opop->subitem_reference_name) {
     MEM_freeN(opop->subitem_reference_name);
@@ -465,9 +469,9 @@ void bke_override_property_operation_clear(IDOverrideStaticPropertyOperation *op
 /**
  * Remove and free given \a override_property_operation from given ID \a override_property.
  */
-void BKE_override_static_property_operation_delete(
-    IDOverrideStaticProperty *override_property,
-    IDOverrideStaticPropertyOperation *override_property_operation)
+void BKE_override_library_property_operation_delete(
+    IDOverrideLibraryProperty *override_property,
+    IDOverrideLibraryPropertyOperation *override_property_operation)
 {
   bke_override_property_operation_clear(override_property_operation);
   BLI_freelinkN(&override_property->operations, override_property_operation);
@@ -483,11 +487,11 @@ void BKE_override_static_property_operation_delete(
  * #IDOverrideProperty (of #IDOverridePropertyOperation) has to be added.
  *
  * \return true if status is OK, false otherwise. */
-bool BKE_override_static_status_check_local(Main *bmain, ID *local)
+bool BKE_override_library_status_check_local(Main *bmain, ID *local)
 {
-  BLI_assert(local->override_static != NULL);
+  BLI_assert(local->override_library != NULL);
 
-  ID *reference = local->override_static->reference;
+  ID *reference = local->override_library->reference;
 
   if (reference == NULL) {
     /* This is an override template, local status is always OK! */
@@ -506,11 +510,11 @@ bool BKE_override_static_status_check_local(Main *bmain, ID *local)
                                    &rnaptr_local,
                                    &rnaptr_reference,
                                    NULL,
-                                   local->override_static,
+                                   local->override_library,
                                    RNA_OVERRIDE_COMPARE_IGNORE_NON_OVERRIDABLE |
                                        RNA_OVERRIDE_COMPARE_IGNORE_OVERRIDDEN,
                                    NULL)) {
-    local->tag &= ~LIB_TAG_OVERRIDESTATIC_REFOK;
+    local->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_REFOK;
     return false;
   }
 
@@ -527,11 +531,11 @@ bool BKE_override_static_status_check_local(Main *bmain, ID *local)
  * needs to be updated against it.
  *
  * \return true if status is OK, false otherwise. */
-bool BKE_override_static_status_check_reference(Main *bmain, ID *local)
+bool BKE_override_library_status_check_reference(Main *bmain, ID *local)
 {
-  BLI_assert(local->override_static != NULL);
+  BLI_assert(local->override_library != NULL);
 
-  ID *reference = local->override_static->reference;
+  ID *reference = local->override_library->reference;
 
   if (reference == NULL) {
     /* This is an override template, reference is virtual, so its status is always OK! */
@@ -540,12 +544,12 @@ bool BKE_override_static_status_check_reference(Main *bmain, ID *local)
 
   BLI_assert(GS(local->name) == GS(reference->name));
 
-  if (reference->override_static && (reference->tag & LIB_TAG_OVERRIDESTATIC_REFOK) == 0) {
-    if (!BKE_override_static_status_check_reference(bmain, reference)) {
+  if (reference->override_library && (reference->tag & LIB_TAG_OVERRIDE_LIBRARY_REFOK) == 0) {
+    if (!BKE_override_library_status_check_reference(bmain, reference)) {
       /* If reference is also override of another data-block, and its status is not OK,
        * then this override is not OK either.
        * Note that this should only happen when reloading libraries... */
-      local->tag &= ~LIB_TAG_OVERRIDESTATIC_REFOK;
+      local->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_REFOK;
       return false;
     }
   }
@@ -558,10 +562,10 @@ bool BKE_override_static_status_check_reference(Main *bmain, ID *local)
                                    &rnaptr_local,
                                    &rnaptr_reference,
                                    NULL,
-                                   local->override_static,
+                                   local->override_library,
                                    RNA_OVERRIDE_COMPARE_IGNORE_OVERRIDDEN,
                                    NULL)) {
-    local->tag &= ~LIB_TAG_OVERRIDESTATIC_REFOK;
+    local->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_REFOK;
     return false;
   }
 
@@ -581,23 +585,23 @@ bool BKE_override_static_status_check_reference(Main *bmain, ID *local)
  * Generating diff values and applying overrides are much cheaper.
  *
  * \return true if new overriding op was created, or some local data was reset. */
-bool BKE_override_static_operations_create(Main *bmain, ID *local, const bool force_auto)
+bool BKE_override_library_operations_create(Main *bmain, ID *local, const bool force_auto)
 {
-  BLI_assert(local->override_static != NULL);
-  const bool is_template = (local->override_static->reference == NULL);
+  BLI_assert(local->override_library != NULL);
+  const bool is_template = (local->override_library->reference == NULL);
   bool ret = false;
 
-  if (!is_template && (force_auto || local->override_static->flag & STATICOVERRIDE_AUTO)) {
+  if (!is_template && (force_auto || local->override_library->flag & OVERRIDE_LIBRARY_AUTO)) {
     PointerRNA rnaptr_local, rnaptr_reference;
     RNA_id_pointer_create(local, &rnaptr_local);
-    RNA_id_pointer_create(local->override_static->reference, &rnaptr_reference);
+    RNA_id_pointer_create(local->override_library->reference, &rnaptr_reference);
 
     eRNAOverrideMatchResult report_flags = 0;
     RNA_struct_override_matches(bmain,
                                 &rnaptr_local,
                                 &rnaptr_reference,
                                 NULL,
-                                local->override_static,
+                                local->override_library,
                                 RNA_OVERRIDE_COMPARE_CREATE | RNA_OVERRIDE_COMPARE_RESTORE,
                                 &report_flags);
     if (report_flags & RNA_OVERRIDE_MATCH_RESULT_CREATED) {
@@ -608,10 +612,10 @@ bool BKE_override_static_operations_create(Main *bmain, ID *local, const bool fo
       printf("We did restore some properties of %s from its reference.\n", local->name);
     }
     if (ret) {
-      printf("We did generate static override rules for %s\n", local->name);
+      printf("We did generate library override rules for %s\n", local->name);
     }
     else {
-      printf("No new static override rules for %s\n", local->name);
+      printf("No new library override rules for %s\n", local->name);
     }
 #endif
   }
@@ -619,31 +623,31 @@ bool BKE_override_static_operations_create(Main *bmain, ID *local, const bool fo
 }
 
 /** Check all overrides from given \a bmain and create/update overriding operations as needed. */
-void BKE_main_override_static_operations_create(Main *bmain, const bool force_auto)
+void BKE_main_override_library_operations_create(Main *bmain, const bool force_auto)
 {
   ID *id;
 
   FOREACH_MAIN_ID_BEGIN (bmain, id) {
     if (force_auto ||
-        (ID_IS_STATIC_OVERRIDE_AUTO(id) && (id->tag & LIB_TAG_OVERRIDESTATIC_AUTOREFRESH))) {
-      BKE_override_static_operations_create(bmain, id, force_auto);
-      id->tag &= ~LIB_TAG_OVERRIDESTATIC_AUTOREFRESH;
+        (ID_IS_OVERRIDE_LIBRARY_AUTO(id) && (id->tag & LIB_TAG_OVERRIDE_LIBRARY_AUTOREFRESH))) {
+      BKE_override_library_operations_create(bmain, id, force_auto);
+      id->tag &= ~LIB_TAG_OVERRIDE_LIBRARY_AUTOREFRESH;
     }
   }
   FOREACH_MAIN_ID_END;
 }
 
 /** Update given override from its reference (re-applying overridden properties). */
-void BKE_override_static_update(Main *bmain, ID *local)
+void BKE_override_library_update(Main *bmain, ID *local)
 {
-  if (local->override_static == NULL || local->override_static->reference == NULL) {
+  if (local->override_library == NULL || local->override_library->reference == NULL) {
     return;
   }
 
   /* Recursively do 'ancestors' overrides first, if any. */
-  if (local->override_static->reference->override_static &&
-      (local->override_static->reference->tag & LIB_TAG_OVERRIDESTATIC_REFOK) == 0) {
-    BKE_override_static_update(bmain, local->override_static->reference);
+  if (local->override_library->reference->override_library &&
+      (local->override_library->reference->tag & LIB_TAG_OVERRIDE_LIBRARY_REFOK) == 0) {
+    BKE_override_library_update(bmain, local->override_library->reference);
   }
 
   /* We want to avoid having to remap here, however creating up-to-date override is much simpler
@@ -662,7 +666,7 @@ void BKE_override_static_update(Main *bmain, ID *local)
    * is actually a (performances) issue here. */
 
   ID *tmp_id;
-  BKE_id_copy(bmain, local->override_static->reference, &tmp_id);
+  BKE_id_copy(bmain, local->override_library->reference, &tmp_id);
 
   if (tmp_id == NULL) {
     return;
@@ -671,13 +675,13 @@ void BKE_override_static_update(Main *bmain, ID *local)
   PointerRNA rnaptr_src, rnaptr_dst, rnaptr_storage_stack, *rnaptr_storage = NULL;
   RNA_id_pointer_create(local, &rnaptr_src);
   RNA_id_pointer_create(tmp_id, &rnaptr_dst);
-  if (local->override_static->storage) {
+  if (local->override_library->storage) {
     rnaptr_storage = &rnaptr_storage_stack;
-    RNA_id_pointer_create(local->override_static->storage, rnaptr_storage);
+    RNA_id_pointer_create(local->override_library->storage, rnaptr_storage);
   }
 
   RNA_struct_override_apply(
-      bmain, &rnaptr_dst, &rnaptr_src, rnaptr_storage, local->override_static);
+      bmain, &rnaptr_dst, &rnaptr_src, rnaptr_storage, local->override_library);
 
   /* This also transfers all pointers (memory) owned by local to tmp_id, and vice-versa.
    * So when we'll free tmp_id, we'll actually free old, outdated data from local. */
@@ -688,15 +692,15 @@ void BKE_override_static_update(Main *bmain, ID *local)
   /* XXX And crashing in complex cases (e.g. because depsgraph uses same data...). */
   BKE_id_free_ex(bmain, tmp_id, LIB_ID_FREE_NO_UI_USER, true);
 
-  if (local->override_static->storage) {
+  if (local->override_library->storage) {
     /* We know this datablock is not used anywhere besides local->override->storage. */
     /* XXX For until we get fully shadow copies, we still need to ensure storage releases
      *     its usage of any ID pointers it may have. */
-    BKE_id_free_ex(bmain, local->override_static->storage, LIB_ID_FREE_NO_UI_USER, true);
-    local->override_static->storage = NULL;
+    BKE_id_free_ex(bmain, local->override_library->storage, LIB_ID_FREE_NO_UI_USER, true);
+    local->override_library->storage = NULL;
   }
 
-  local->tag |= LIB_TAG_OVERRIDESTATIC_REFOK;
+  local->tag |= LIB_TAG_OVERRIDE_LIBRARY_REFOK;
 
   /* Full rebuild of Depsgraph! */
   DEG_on_visible_update(
@@ -705,13 +709,13 @@ void BKE_override_static_update(Main *bmain, ID *local)
 }
 
 /** Update all overrides from given \a bmain. */
-void BKE_main_override_static_update(Main *bmain)
+void BKE_main_override_library_update(Main *bmain)
 {
   ID *id;
 
   FOREACH_MAIN_ID_BEGIN (bmain, id) {
-    if (id->override_static != NULL && id->lib == NULL) {
-      BKE_override_static_update(bmain, id);
+    if (id->override_library != NULL && id->lib == NULL) {
+      BKE_override_library_update(bmain, id);
     }
   }
   FOREACH_MAIN_ID_END;
@@ -735,7 +739,7 @@ void BKE_main_override_static_update(Main *bmain)
  */
 
 /** Initialize an override storage. */
-OverrideStaticStorage *BKE_override_static_operations_store_initialize(void)
+OverrideLibraryStorage *BKE_override_library_operations_store_initialize(void)
 {
   return BKE_main_new();
 }
@@ -745,13 +749,13 @@ OverrideStaticStorage *BKE_override_static_operations_store_initialize(void)
  *
  * Note that \a local ID is no more modified by this call,
  * all extra data are stored in its temp \a storage_id copy. */
-ID *BKE_override_static_operations_store_start(Main *bmain,
-                                               OverrideStaticStorage *override_storage,
-                                               ID *local)
+ID *BKE_override_library_operations_store_start(Main *bmain,
+                                                OverrideLibraryStorage *override_storage,
+                                                ID *local)
 {
-  BLI_assert(local->override_static != NULL);
+  BLI_assert(local->override_library != NULL);
   BLI_assert(override_storage != NULL);
-  const bool is_template = (local->override_static->reference == NULL);
+  const bool is_template = (local->override_library->reference == NULL);
 
   if (is_template) {
     /* This is actually purely local data with an override template, nothing to do here! */
@@ -759,7 +763,7 @@ ID *BKE_override_static_operations_store_start(Main *bmain,
   }
 
   /* Forcefully ensure we know about all needed override operations. */
-  BKE_override_static_operations_create(bmain, local, false);
+  BKE_override_library_operations_create(bmain, local, false);
 
   ID *storage_id;
 #ifdef DEBUG_OVERRIDE_TIMEIT
@@ -777,18 +781,18 @@ ID *BKE_override_static_operations_store_start(Main *bmain,
 
   if (storage_id != NULL) {
     PointerRNA rnaptr_reference, rnaptr_final, rnaptr_storage;
-    RNA_id_pointer_create(local->override_static->reference, &rnaptr_reference);
+    RNA_id_pointer_create(local->override_library->reference, &rnaptr_reference);
     RNA_id_pointer_create(local, &rnaptr_final);
     RNA_id_pointer_create(storage_id, &rnaptr_storage);
 
     if (!RNA_struct_override_store(
-            bmain, &rnaptr_final, &rnaptr_reference, &rnaptr_storage, local->override_static)) {
+            bmain, &rnaptr_final, &rnaptr_reference, &rnaptr_storage, local->override_library)) {
       BKE_id_free_ex(override_storage, storage_id, LIB_ID_FREE_NO_UI_USER, true);
       storage_id = NULL;
     }
   }
 
-  local->override_static->storage = storage_id;
+  local->override_library->storage = storage_id;
 
 #ifdef DEBUG_OVERRIDE_TIMEIT
   TIMEIT_END_AVERAGED(BKE_override_operations_store_start);
@@ -797,17 +801,17 @@ ID *BKE_override_static_operations_store_start(Main *bmain,
 }
 
 /** Restore given ID modified by \a BKE_override_operations_store_start, to its original state. */
-void BKE_override_static_operations_store_end(OverrideStaticStorage *UNUSED(override_storage),
-                                              ID *local)
+void BKE_override_library_operations_store_end(OverrideLibraryStorage *UNUSED(override_storage),
+                                               ID *local)
 {
-  BLI_assert(local->override_static != NULL);
+  BLI_assert(local->override_library != NULL);
 
   /* Nothing else to do here really, we need to keep all temp override storage data-blocks in
    * memory until whole file is written anyway (otherwise we'd get mem pointers overlap...). */
-  local->override_static->storage = NULL;
+  local->override_library->storage = NULL;
 }
 
-void BKE_override_static_operations_store_finalize(OverrideStaticStorage *override_storage)
+void BKE_override_library_operations_store_finalize(OverrideLibraryStorage *override_storage)
 {
   /* We cannot just call BKE_main_free(override_storage), not until we have option to make 'ghost'
    * copies of IDs without increasing usercount of used data-blocks. */
diff --git a/source/blender/blenkernel/intern/library_query.c b/source/blender/blenkernel/intern/library_query.c
index 2b8973ff873..8bbc0bb8ae1 100644
--- a/source/blender/blenkernel/intern/library_query.c
+++ b/source/blender/blenkernel/intern/library_query.c
@@ -428,11 +428,11 @@ static void library_foreach_ID_link(Main *bmain,
       continue;
     }
 
-    if (id->override_static != NULL) {
-      CALLBACK_INVOKE_ID(id->override_static->reference,
-                         IDWALK_CB_USER | IDWALK_CB_STATIC_OVERRIDE_REFERENCE);
-      CALLBACK_INVOKE_ID(id->override_static->storage,
-                         IDWALK_CB_USER | IDWALK_CB_STATIC_OVERRIDE_REFERENCE);
+    if (id->override_library != NULL) {
+      CALLBACK_INVOKE_ID(id->override_library->reference,
+                         IDWALK_CB_USER | IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE);
+      CALLBACK_INVOKE_ID(id->override_library->storage,
+                         IDWALK_CB_USER | IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE);
     }
 
     library_foreach_idproperty_ID_link(&data, id->properties, IDWALK_CB_USER);
diff --git a/source/blender/blenkernel/intern/library_remap.c b/source/blender/blenkernel/intern/library_remap.c
index fb457c9f678..934544b3173 100644
--- a/source/blender/blenkernel/intern/library_remap.c
+++ b/source/blender/blenkernel/intern/library_remap.c
@@ -191,7 +191,7 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
       new_id = NULL;
     }
 
-    const bool is_reference = (cb_flag & IDWALK_CB_STATIC_OVERRIDE_REFERENCE) != 0;
+    const bool is_reference = (cb_flag & IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE) != 0;
     const bool is_indirect = (cb_flag & IDWALK_CB_INDIRECT_USAGE) != 0;
     const bool skip_indirect = (id_remap_data->flag & ID_REMAP_SKIP_INDIRECT_USAGE) != 0;
     /* Note: proxy usage implies LIB_TAG_EXTERN, so on this aspect it is direct,
@@ -202,7 +202,7 @@ static int foreach_libblock_remap_callback(void *user_data, ID *id_self, ID **id
     const bool is_obj_editmode = (is_obj && BKE_object_is_in_editmode((Object *)id));
     const bool is_never_null = ((cb_flag & IDWALK_CB_NEVER_NULL) && (new_id == NULL) &&
                                 (id_remap_data->flag & ID_REMAP_FORCE_NEVER_NULL_USAGE) == 0);
-    const bool skip_reference = (id_remap_data->flag & ID_REMAP_SKIP_STATIC_OVERRIDE) != 0;
+    const bool skip_reference = (id_remap_data->flag & ID_REMAP_SKIP_OVERRIDE_LIBRARY) != 0;
     const bool skip_never_null = (id_remap_data->flag & ID_REMAP_SKIP_NEVER_NULL_USAGE) != 0;
 
 #ifdef DEBUG_PRINT
@@ -756,8 +756,8 @@ void BKE_libblock_free_data(ID *id, const bool do_id_user)
     MEM_freeN(id->properties);
   }
 
-  if (id->override_static) {
-    BKE_override_static_free(&id->override_static);
+  if (id->override_library) {
+    BKE_override_library_free(&id->override_library);
   }
 
   /* XXX TODO remove animdata handling from each type's freeing func,
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index 24ba7209619..2254207e545 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -128,7 +128,7 @@ ModifierData *modifier_new(int type)
 
   md->type = type;
   md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
-  md->flag = eModifierFlag_StaticOverride_Local;
+  md->flag = eModifierFlag_OverrideLibrary_Local;
 
   if (mti->flags & eModifierTypeFlag_EnableInEditmode) {
     md->mode |= eModifierMode_Editmode;
diff --git a/source/blender/blenkernel/intern/shader_fx.c b/source/blender/blenkernel/intern/shader_fx.c
index 75503b8ca10..c999e1ad14e 100644
--- a/source/blender/blenkernel/intern/shader_fx.c
+++ b/source/blender/blenkernel/intern/shader_fx.c
@@ -83,7 +83,7 @@ ShaderFxData *BKE_shaderfx_new(int type)
 
   fx->type = type;
   fx->mode = eShaderFxMode_Realtime | eShaderFxMode_Render | eShaderFxMode_Expanded;
-  fx->flag = eShaderFxFlag_StaticOverride_Local;
+  fx->flag = eShaderFxFlag_OverrideLibrary_Local;
 
   if (fxi->flags & eShaderFxTypeFlag_EnableInEditmode) {
     fx->mode |= eShaderFxMode_Editmode;
diff --git a/source/blender/blenkernel/intern/undo_system.c b/source/blender/blenkernel/intern/undo_system.c
index caf88eb0fff..b33884e4f0e 100644
--- a/source/blender/blenkernel/intern/undo_system.c
+++ b/source/blender/blenkernel/intern/undo_system.c
@@ -505,8 +505,8 @@ bool BKE_undosys_step_push_with_type(UndoStack *ustack,
 
   /* Might not be final place for this to be called - probably only want to call it from some
    * undo handlers, not all of them? */
-  if (BKE_override_static_is_enabled()) {
-    BKE_main_override_static_operations_create(G.main, false);
+  if (BKE_override_library_is_enabled()) {
+    BKE_main_override_library_operations_create(G.main, false);
   }
 
   /* Remove all undos after (also when 'ustack->step_active == NULL'). */