Unwraps any RefinementTrackingFlowScopes.
191421
private static FlowScope unwrap(FlowScope scope) {
    while (scope instanceof RefinementTrackingFlowScope) {
      scope = ((RefinementTrackingFlowScope) scope).delegate;
    }
    return scope;
  }
106544
def _clean_bindings(self, bindings):
        
        return list(filter(lambda b: not isinstance(b, QueryExpression), bindings))
375778
def _clear_scope_decos(self):
        """"""
        for deco in self._scope_decos:
            self.editor.decorations.remove(deco)
        self._scope_decos[:] = []
171280
void removeInlinedFunctions() {
    for (Map.Entry<String, FunctionState> entry : fns.entrySet()) {
      String name = entry.getKey();
      FunctionState functionState = entry.getValue();
      if (functionState.canRemove()) {
        Function fn = functionState.getFn();
        checkState(functionState.canInline());
        checkState(fn != null);
        verifyAllReferencesInlined(name, functionState);
        fn.remove();
        NodeUtil.markFunctionsDeleted(fn.getFunctionNode(), compiler);
      }
    }
  }
258213
private boolean cleanupInventory() {
		boolean modified = false;
		modified |= removeUnreadable();
		modified |= recreateMismatching();
		modified |= importConfigurations();
		return modified;
	}
1363096
private synchronized void cleanSubsequentStalePages()
   {
      // FIXME: Workaround until FORGE-1704 is fixed
      if (flowPointer == 0)
      {
         flow.subList(1, flow.size()).clear();
         subflow.clear();
      }
      else
      {
         // Remove subsequent pages and push the subflows back to the stack
         Iterator<WizardStepEntry> it = flow.listIterator(flowPointer + 1);
         int subflowIdx = 0;
         while (it.hasNext())
         {
            WizardStepEntry entry = it.next();
            if (entry.subflowHead && !subflow.contains(entry))
            {
               subflow.add(subflowIdx++, entry);
            }
            it.remove();
         }
      }
   }
607853
def reset(self):
        
        super(SinonSpy, self).unwrap()
        super(SinonSpy, self).wrap2spy()
954055
public static IDocTypeProcessor unwrap(final IDocTypeProcessor processor) {
        if (processor == null) {
            return null;
        }
        if (processor instanceof AbstractProcessorWrapper) {
            return (IDocTypeProcessor)((AbstractProcessorWrapper) processor).unwrap();
        }
        return processor;
    }
758601
def untrace_property(cls, accessor):
    

    if not is_traced(accessor.fget) or not is_traced(accessor.fset) or not is_traced(accessor.fdel):
        return False

    name = get_method_name(accessor)
    setattr(cls, name, property(untracer(accessor.fget),
                                untracer(accessor.fset),
                                untracer(accessor.fdel)))
    return True
1147759
private void reflectionStrippedProcessing() {
        HashMap<Object, Object> newEntries = new HashMap<>();
        for (Map.Entry<Object, Object> entry : props.entrySet()) {
            String key = (String) entry.getKey();
            int index = key.lastIndexOf('.');
            if (index == -1 || index == 0 || index == key.length() - 1) {
                continue;
            }
            String prefix = key.substring(0, index);
            String suffix = key.substring(index + 1);
            String newKey = ReflectionUtil.getCamelCase(prefix) + "." + suffix;
            if (!props.containsKey(newKey)) {
                newEntries.put(newKey, entry.getValue());
            }
        }
        props.putAll(newEntries);
    }
833779
def untrace_module(module):
    

    for name, function in inspect.getmembers(module, inspect.isfunction):
        untrace_function(module, function)

    for name, cls in inspect.getmembers(module, inspect.isclass):
        untrace_class(cls)

    set_untraced(module)

    return True
1149666
def untrace_class(cls):
    

    for name, method in inspect.getmembers(cls, inspect.ismethod):
        untrace_method(cls, method)

    for name, function in inspect.getmembers(cls, inspect.isfunction):
        untrace_method(cls, function)

    for name, accessor in inspect.getmembers(cls, lambda x: type(x) is property):
        untrace_property(cls, accessor)

    set_untraced(cls)

    return True
441757
def unwrap(self):
        """"""
        return [v.unwrap() if hasattr(v, 'unwrap') and not hasattr(v, 'no_unwrap') else v for v in self]
819057
public static Throwable unwrap(Throwable wrapped) {
		Throwable unwrapped = wrapped;
		while (true) {
			if (unwrapped instanceof InvocationTargetException) {
				unwrapped = ((InvocationTargetException) unwrapped).getTargetException();
			} else if (unwrapped instanceof UndeclaredThrowableException) {
				unwrapped = ((UndeclaredThrowableException) unwrapped).getUndeclaredThrowable();
			} else {
				return unwrapped;
			}
		}
	}
792076
private void detachDecorators(@NonNull final DialogRootView rootView) {
        for (AbstractDecorator<?, ?> decorator : decorators) {
            decorator.detach();
            decorator.removeAreaListener(rootView);
        }
    }
1162663
private void removeDuplicateDeclarations(Node externs, Node root) {
    Callback tickler = new ScopeTicklingCallback();
    ScopeCreator scopeCreator =
        new Es6SyntacticScopeCreator(compiler, new DuplicateDeclarationHandler());
    NodeTraversal t = new NodeTraversal(compiler, tickler, scopeCreator);
    t.traverseRoots(externs, root);
  }
1338795
public void unwrap(InputStream inStream, OutputStream outStream,
                       MessageProp msgProp)
        throws GSSException {
        throw new GSSException(GSSException.UNAVAILABLE);
    }