Assign the `member_of` of child members and call
            their `_afterpass()`.

            This should only be called after the object is fully built.
170233
def _afterpass(self):
        
        for codeobj in self.members:
            if not codeobj.is_definition:
                if not codeobj._definition is None:
                    codeobj._definition.member_of = self
            codeobj._afterpass()
627943
public function afterConstruct()
    {
        if (! isset($this->attributes['permissions'])) {
            $this->permissions = $this->factory->create(RolePermission::class);
        }
    }
578659
def emit_block_member_prefix(members, current_member)
      previous_member_index = members.index(current_member) - 1
      previous_member = previous_member_index >= 0 ? members[previous_member_index] : nil
      return "" unless previous_member
      
      [
        [[:defn, :defs, :iter, :class, :module, :rescue], [:defn, :defs, :iter, :class, :module, :call, :rescue]],
        [[:call], [:defn, :defs, :iter, :class, :module]]
      ].each do |from, to|
        return nl if (from == :any || from.include?(previous_member.kind)) && (to == :any || to.include?(current_member.kind))
      end
      
      if current_member.conditional? && [:block_if, :block_unless].include?(determine_if_type(current_member))
        return nl
      elsif previous_member.conditional? && [:block_if, :block_unless].include?(determine_if_type(previous_member))
        return nl
      end
      
      if previous_member.call? && grouped_methods.include?(previous_member.name.to_s) && (!current_member.call? || (current_member.call? && current_member.name != previous_member.name))
        return nl
      end
      
      if current_member.call? && grouped_methods.include?(current_member.name.to_s) && (!previous_member.call? || (previous_member.call? && previous_member.name != current_member.name))
        return nl
      end
      
      ""
    end
1367181
public void afterConstructor(PageContext pc, Variables parent) throws ApplicationException {
	pc.setVariablesScope(parent);
	this.afterConstructor = true;

	/*
	 * if(constructorUDFs!=null){ Iterator<Entry<Key, UDF>> it = constructorUDFs.entrySet().iterator();
	 * Map.Entry<Key, UDF> entry; Key key; UDFPlus udf; PageSource ps; while(it.hasNext()){
	 * entry=it.next(); key=entry.getKey(); udf=(UDFPlus) entry.getValue(); ps=udf.getPageSource();
	 * //if(ps!=null && ps.equals(getPageSource()))continue; // TODO can we avoid that udfs from the
	 * component itself are here? registerUDF(key, udf,false,true); } }
	 */
    }
1143340
public function afterRegistry()
    {
        parent::afterRegistry();

        $this->initTranslateable();

        $this->_ensureSettings();

        // Load the masker classes
        foreach ($this->_settings as $name => $setting) {
            if (isset($setting['class'], $setting['maskFields'])) {
                $this->_settings[$name]['masker'] = $this->_loadClass(
                        $setting['class'],
                        true,
                        array($setting['maskFields'])
                        );
            }
        }

        // Create the fieldlist
        $this->_fieldList = array();
        foreach ($this->_settings as $name => $setting) {
            if (isset($setting['class'], $setting['maskFields'])) {
                foreach ($setting['maskFields'] as $field => $type) {
                    $this->_fieldList[$field] = $name;
                }
            }
        }
    }
442025
def after(self):
        

        d = Deferred()
        self._after_deferreds.append(d)
        return d.chain
1087453
def connect_after(self, slot, *extra_args):
        
        slot = Slot(slot, *extra_args)
        self._after_functions.add(slot)
546786
function (member) {
        _gpfAsserts({
            "Expected a _GpfClassDefMember": member instanceof _GpfClassDefMember,
            "Member is already assigned to a class": null === member._classDef
        });
        this._checkMemberBeforeAdd(member);
        this._members[member.getName()] = member;
        member._classDef = this;
        return this;
    }
1093156
function(context, descriptor, args, stack) {
		var path = args[0],
			template = args[1],
			ctx = stack.shift(),
			oldCtx = descriptor.context;
		descriptor.context = ctx;
		secondPass(template, ctx, descriptor, stack);
		descriptor.context = oldCtx;
	}
1109736
def add_child(self, frame, after=None):
        '''
        
        '''
        frame.remove_from_parent()
        frame.parent = self
        if after is None:
            self._children.append(frame)
        else:
            index = self._children.index(after) + 1
            self._children.insert(index, frame)

        self._invalidate_time_caches()
997684
def visitMember(self, ctx: jsgParser.MemberContext):
        
        self._strict = ctx.COMMA() is None
        self.visitChildren(ctx)
1287273
@PostConstruct
	protected void postConstruct() {
		if (null == authenticationServices) {
			authenticationServices = new ArrayList<AuthenticationService>();
		}
		if (!excludeDefault) {
			authenticationServices.add(staticAuthenticationService);
		}
	}
216460
def after_array(node)
      builder = DefinitionBuilder::RubyArray.new(
        node,
        self,
        :values => value_stack.pop
      )

      push_value(builder.build)
    end
1029069
function (member, memberValue, visibility) {
        var newType = typeof memberValue,
            baseMemberValue,
            baseType,
            prototype = this._Constructor.prototype;
        _gpfAssert(!prototype.hasOwnProperty(member), "Existing own member can't be overridden");
        baseMemberValue = this._Super.prototype[member];
        baseType = typeof baseMemberValue;
        if ("undefined" !== baseType) {
            if (null !== baseMemberValue && newType !== baseType) {
                gpf.Error.classMemberOverloadWithTypeChange();
            }
            if ("function" === newType && _gpfUsesSuper(memberValue)) {
                memberValue = _gpfGenSuperMember(baseMemberValue, memberValue);
            }
        }
        _gpfIgnore(visibility); // TODO Handle constructor visibility
        prototype[member] = memberValue;
    }
260714
def _handle_start_member(self, attrs):
        

        params = {
            # ToDo: Parse attributes
            'attributes': {},
            'ref': None,
            'result': self._result,
            'role': None
        }
        if attrs.get('ref', None):
            params['ref'] = int(attrs['ref'])
        if attrs.get('role', None):
            params['role'] = attrs['role']

        cls_map = {
            "area": RelationArea,
            "node": RelationNode,
            "relation": RelationRelation,
            "way": RelationWay
        }
        cls = cls_map.get(attrs["type"])
        if cls is None:
            raise ValueError("Undefined type for member: '%s'" % attrs['type'])

        self.cur_relation_member = cls(**params)
        self._curr['members'].append(self.cur_relation_member)
860007
def after(self, i, sibling, name=None):
        """"""
        self.parent._insert(sibling, idx=self._own_index + 1 + i, name=name)
        return self
1347584
def after(self, after):
        
        if after is not None and len(after) > 32:
            raise ValueError("Invalid value for `after`, length must be less than or equal to `32`")
        if after is not None and len(after) < 32:
            raise ValueError("Invalid value for `after`, length must be greater than or equal to `32`")

        self._after = after