refactor(reactivity): improve tree-shaking annotations

packages/reactivity/src/baseHandlers.ts

@@ -42,12 +42,15 @@ const shallowGet = /*#__PURE__*/ createGetter(false, true)
 const readonlyGet = /*#__PURE__*/ createGetter(true)
 const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true)
 
-const arrayInstrumentations: Record<string, Function> = {}
+const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations()
-// instrument identity-sensitive Array methods to account for possible reactive
+
-// values
+function createArrayInstrumentations() {
-;(['includes', 'indexOf', 'lastIndexOf'] as const).forEach(key => {
+  const instrumentations: Record<string, Function> = {}
+  // instrument identity-sensitive Array methods to account for possible reactive
+  // values
+  ;(['includes', 'indexOf', 'lastIndexOf'] as const).forEach(key => {
     const method = Array.prototype[key] as any
-  arrayInstrumentations[key] = function(this: unknown[], ...args: unknown[]) {
+    instrumentations[key] = function(this: unknown[], ...args: unknown[]) {
       const arr = toRaw(this)
       for (let i = 0, l = this.length; i < l; i++) {
         track(arr, TrackOpTypes.GET, i + '')
@@ -61,18 +64,20 @@ const arrayInstrumentations: Record<string, Function> = {}
         return res
       }
     }
-})
+  })
-// instrument length-altering mutation methods to avoid length being tracked
+  // instrument length-altering mutation methods to avoid length being tracked
-// which leads to infinite loops in some cases (#2137)
+  // which leads to infinite loops in some cases (#2137)
-;(['push', 'pop', 'shift', 'unshift', 'splice'] as const).forEach(key => {
+  ;(['push', 'pop', 'shift', 'unshift', 'splice'] as const).forEach(key => {
     const method = Array.prototype[key] as any
-  arrayInstrumentations[key] = function(this: unknown[], ...args: unknown[]) {
+    instrumentations[key] = function(this: unknown[], ...args: unknown[]) {
       pauseTracking()
       const res = method.apply(this, args)
       resetTracking()
       return res
     }
-})
+  })
+  return instrumentations
+}
 
 function createGetter(isReadonly = false, shallow = false) {
   return function get(target: Target, key: string | symbol, receiver: object) {
@@ -224,7 +229,7 @@ export const readonlyHandlers: ProxyHandler<object> = {
   }
 }
 
-export const shallowReactiveHandlers: ProxyHandler<object> = extend(
+export const shallowReactiveHandlers = /*#__PURE__*/ extend(
   {},
   mutableHandlers,
   {
@@ -236,7 +241,7 @@ export const shallowReactiveHandlers: ProxyHandler<object> = extend(
 // Props handlers are special in the sense that it should not unwrap top-level
 // refs (in order to allow refs to be explicitly passed down), but should
 // retain the reactivity of the normal readonly object.
-export const shallowReadonlyHandlers: ProxyHandler<object> = extend(
+export const shallowReadonlyHandlers = /*#__PURE__*/ extend(
   {},
   readonlyHandlers,
   {

packages/reactivity/src/collectionHandlers.ts

@@ -236,7 +236,8 @@ function createReadonlyMethod(type: TriggerOpTypes): Function {
   }
 }
 
-const mutableInstrumentations: Record<string, Function> = {
+function createInstrumentations() {
+  const mutableInstrumentations: Record<string, Function> = {
     get(this: MapTypes, key: unknown) {
       return get(this, key)
     },
@@ -249,9 +250,9 @@ const mutableInstrumentations: Record<string, Function> = {
     delete: deleteEntry,
     clear,
     forEach: createForEach(false, false)
-}
+  }
 
-const shallowInstrumentations: Record<string, Function> = {
+  const shallowInstrumentations: Record<string, Function> = {
     get(this: MapTypes, key: unknown) {
       return get(this, key, false, true)
     },
@@ -264,9 +265,9 @@ const shallowInstrumentations: Record<string, Function> = {
     delete: deleteEntry,
     clear,
     forEach: createForEach(false, true)
-}
+  }
 
-const readonlyInstrumentations: Record<string, Function> = {
+  const readonlyInstrumentations: Record<string, Function> = {
     get(this: MapTypes, key: unknown) {
       return get(this, key, true)
     },
@@ -281,9 +282,9 @@ const readonlyInstrumentations: Record<string, Function> = {
     delete: createReadonlyMethod(TriggerOpTypes.DELETE),
     clear: createReadonlyMethod(TriggerOpTypes.CLEAR),
     forEach: createForEach(true, false)
-}
+  }
 
-const shallowReadonlyInstrumentations: Record<string, Function> = {
+  const shallowReadonlyInstrumentations: Record<string, Function> = {
     get(this: MapTypes, key: unknown) {
       return get(this, key, true, true)
     },
@@ -298,10 +299,10 @@ const shallowReadonlyInstrumentations: Record<string, Function> = {
     delete: createReadonlyMethod(TriggerOpTypes.DELETE),
     clear: createReadonlyMethod(TriggerOpTypes.CLEAR),
     forEach: createForEach(true, true)
-}
+  }
 
-const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]
+  const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]
-iteratorMethods.forEach(method => {
+  iteratorMethods.forEach(method => {
     mutableInstrumentations[method as string] = createIterableMethod(
       method,
       false,
@@ -322,7 +323,22 @@ iteratorMethods.forEach(method => {
       true,
       true
     )
-})
+  })
+
+  return [
+    mutableInstrumentations,
+    readonlyInstrumentations,
+    shallowInstrumentations,
+    shallowReadonlyInstrumentations
+  ]
+}
+
+const [
+  mutableInstrumentations,
+  readonlyInstrumentations,
+  shallowInstrumentations,
+  shallowReadonlyInstrumentations
+] = /* #__PURE__*/ createInstrumentations()
 
 function createInstrumentationGetter(isReadonly: boolean, shallow: boolean) {
   const instrumentations = shallow
@@ -357,21 +373,21 @@ function createInstrumentationGetter(isReadonly: boolean, shallow: boolean) {
 }
 
 export const mutableCollectionHandlers: ProxyHandler<CollectionTypes> = {
-  get: createInstrumentationGetter(false, false)
+  get: /*#__PURE__*/ createInstrumentationGetter(false, false)
 }
 
 export const shallowCollectionHandlers: ProxyHandler<CollectionTypes> = {
-  get: createInstrumentationGetter(false, true)
+  get: /*#__PURE__*/ createInstrumentationGetter(false, true)
 }
 
 export const readonlyCollectionHandlers: ProxyHandler<CollectionTypes> = {
-  get: createInstrumentationGetter(true, false)
+  get: /*#__PURE__*/ createInstrumentationGetter(true, false)
 }
 
 export const shallowReadonlyCollectionHandlers: ProxyHandler<
   CollectionTypes
 > = {
-  get: createInstrumentationGetter(true, true)
+  get: /*#__PURE__*/ createInstrumentationGetter(true, true)
 }
 
 function checkIdentityKeys(