Function updateClassInstance

lib/assets/react-source/development/react.js:16848–16959

(current, workInProgress, ctor, newProps, renderExpirationTime)

	function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
	  var instance = workInProgress.stateNode;
	  cloneUpdateQueue(current, workInProgress);
	  var oldProps = workInProgress.memoizedProps;
	  instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
	  var oldContext = instance.context;
	  var contextType = ctor.contextType;
	  var nextContext = emptyContextObject;

	  if (typeof contextType === 'object' && contextType !== null) {
	    nextContext = readContext(contextType);
	  } else {
	    var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
	    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
	  }

	  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
	  var hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what
	  // ever the previously attempted to render - not the "current". However,
	  // during componentDidUpdate we pass the "current" props.
	  // In order to support react-lifecycles-compat polyfilled components,
	  // Unsafe lifecycles should not be invoked for components using the new APIs.

	  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {
	    if (oldProps !== newProps || oldContext !== nextContext) {
	      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
	    }
	  }

	  resetHasForceUpdateBeforeProcessing();
	  var oldState = workInProgress.memoizedState;
	  var newState = instance.state = oldState;
	  processUpdateQueue(workInProgress, newProps, instance, renderExpirationTime);
	  newState = workInProgress.memoizedState;

	  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
	    // If an update was already in progress, we should schedule an Update
	    // effect even though we're bailing out, so that cWU/cDU are called.
	    if (typeof instance.componentDidUpdate === 'function') {
	      if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
	        workInProgress.effectTag |= Update;
	      }
	    }

	    if (typeof instance.getSnapshotBeforeUpdate === 'function') {
	      if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
	        workInProgress.effectTag |= Snapshot;
	      }
	    }

	    return false;
	  }

	  if (typeof getDerivedStateFromProps === 'function') {
	    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
	    newState = workInProgress.memoizedState;
	  }