Make the second argument the super of the first argument

@throws GraqlQueryException if the types are different, or setting the super to be a meta-type
181360
public static void setSuper(SchemaConcept subConcept, SchemaConcept superConcept) {
        if (superConcept.isEntityType()) {
            subConcept.asEntityType().sup(superConcept.asEntityType());
        } else if (superConcept.isRelationType()) {
            subConcept.asRelationType().sup(superConcept.asRelationType());
        } else if (superConcept.isRole()) {
            subConcept.asRole().sup(superConcept.asRole());
        } else if (superConcept.isAttributeType()) {
            subConcept.asAttributeType().sup(superConcept.asAttributeType());
        } else if (superConcept.isRule()) {
            subConcept.asRule().sup(superConcept.asRule());
        } else {
            throw InvalidKBException.insertMetaType(subConcept.label(), superConcept);
        }
    }
959706
@SuppressWarnings("rawtypes")
    public static void populateArgumentsForCriteria(
            PersistentEntity entity,
            CriteriaQuery query,
            Root queryRoot,
            CriteriaBuilder criteriaBuilder,
            Map argMap,
            ConversionService conversionService,
            boolean useDefaultMapping) {
        String orderParam = (String) argMap.get(DynamicFinder.ARGUMENT_ORDER);
        Object fetchObj = argMap.get(DynamicFinder.ARGUMENT_FETCH);
        if (fetchObj instanceof Map) {
            Map fetch = (Map) fetchObj;
            for (Object o : fetch.keySet()) {
                String associationName = (String) o;

                final FetchMode fetchMode = getFetchMode(fetch.get(associationName));
                if (fetchMode == FetchMode.JOIN) {
                    queryRoot.join(associationName);
                }
            }
        }

        final Object sortObj = argMap.get(DynamicFinder.ARGUMENT_SORT);
        if (sortObj != null) {
            boolean ignoreCase = true;
            Object caseArg = argMap.get(DynamicFinder.ARGUMENT_IGNORE_CASE);
            if (caseArg instanceof Boolean) {
                ignoreCase = (Boolean) caseArg;
            }
            if (sortObj instanceof Map) {
                Map sortMap = (Map) sortObj;
                for (Object sort : sortMap.keySet()) {
                    final String order = DynamicFinder.ORDER_DESC.equalsIgnoreCase((String) sortMap.get(sort)) ? DynamicFinder.ORDER_DESC : DynamicFinder.ORDER_ASC;
                    addOrderPossiblyNested(query,queryRoot, criteriaBuilder, entity, (String) sort, order, ignoreCase);
                }
            } else {
                final String sort = (String) sortObj;
                final String order = DynamicFinder.ORDER_DESC.equalsIgnoreCase(orderParam) ? DynamicFinder.ORDER_DESC : DynamicFinder.ORDER_ASC;
                addOrderPossiblyNested(query, queryRoot, criteriaBuilder,entity, sort, order, ignoreCase);
            }
        } else if (useDefaultMapping) {
            Mapping m = AbstractGrailsDomainBinder.getMapping(entity.getJavaClass());
            if (m != null) {
                Map sortMap = m.getSort().getNamesAndDirections();
                for (Object sort : sortMap.keySet()) {
                    final String order = DynamicFinder.ORDER_DESC.equalsIgnoreCase((String) sortMap.get(sort)) ? DynamicFinder.ORDER_DESC : DynamicFinder.ORDER_ASC;
                    addOrderPossiblyNested(query,queryRoot, criteriaBuilder, entity, (String) sort, order, true);
                }
            }
        }
    }
253757
function _gpfClassSuperCreate (superMember) {
    var superMethod;
    if (typeof superMember === "function") {
        superMethod = superMember;
    } else {
        superMethod = _gpfClassNoSuper;
    }
    return _gpfClassSuperCreateWithSameSignature(superMethod);
}
818381
public static <T> Predicate<T> and(final Predicate<? super T> first, final Predicate<? super T> second) {
        return new Predicate<T>() {
            @Override
            public boolean test(final T testValue) {
                return first.test(testValue) && second.test(testValue);
            }
        };
    }
726647
public void setExtends(String superType) {
		if (!Strings.isEmpty(superType)
				&& !Agent.class.getName().equals(superType)) {
			JvmParameterizedTypeReference superTypeRef = newTypeRef(this.sarlAgent, superType);
			JvmTypeReference baseTypeRef = findType(this.sarlAgent, Agent.class.getCanonicalName());
			if (isSubTypeOf(this.sarlAgent, superTypeRef, baseTypeRef)) {
				this.sarlAgent.setExtends(superTypeRef);
				return;
			}
		}
		this.sarlAgent.setExtends(null);
	}
1362679
private function executeGqlAsBasicQuery(ProtocolMessage $obj_gql_request)
    {
        // Set up the new request
        $obj_query_request = $this->setupRunQuery();
        $obj_query = $obj_query_request->mutableQuery();

        // Transfer any transaction data to the new request
        /** @var RunQueryRequest $obj_gql_request */
        if($obj_gql_request->mutableReadOptions()->hasTransaction()) {
            $obj_query_request->mutableReadOptions()->setTransaction($obj_gql_request->mutableReadOptions()->getTransaction());
        }

        // Parse the GQL string
        $obj_gql_query = $obj_gql_request->getGqlQuery();
        $obj_parser = new ProtoBufGQLParser($this->obj_schema);
        $obj_parser->parse($obj_gql_query->getQueryString(), $obj_gql_query->getNameArgList());

        // Start applying to the new RunQuery request
        $obj_query->addKind()->setName($obj_parser->getKind());
        foreach($obj_parser->getOrderBy() as $arr_order_by) {
            $obj_query->addOrder()->setDirection($arr_order_by['direction'])->mutableProperty()->setName($arr_order_by['property']);
        }

        // Limits, Offsets, Cursors
        $obj_parser->getLimit() && $obj_query->setLimit($obj_parser->getLimit());
        $obj_parser->getOffset() && $obj_query->setOffset($obj_parser->getOffset());
        $obj_parser->getStartCursor() && $obj_query->setStartCursor($obj_parser->getStartCursor());
        // @todo @ $obj_query->setEndCursor();

        // Filters
        $int_filters = count($obj_parser->getFilters());
        if(1 === $int_filters) {
            $this->configureFilterFromGql($obj_query->mutableFilter()->mutablePropertyFilter(), $obj_parser->getFilters()[0]);
        } else if (1 < $int_filters) {
            $obj_composite_filter = $obj_query->mutableFilter()->mutableCompositeFilter()->setOperator(\google\appengine\datastore\v4\CompositeFilter\Operator::AND_);
            foreach ($obj_parser->getFilters() as $arr_filter) {
                $this->configureFilterFromGql($obj_composite_filter->addFilter()->mutablePropertyFilter(), $arr_filter);
            }
        }
        return $this->execute('RunQuery', $obj_query_request, new RunQueryResponse());
    }
1181017
public void setExtends(String superType) {
		if (!Strings.isEmpty(superType)
				&& !Behavior.class.getName().equals(superType)) {
			JvmParameterizedTypeReference superTypeRef = newTypeRef(this.sarlBehavior, superType);
			JvmTypeReference baseTypeRef = findType(this.sarlBehavior, Behavior.class.getCanonicalName());
			if (isSubTypeOf(this.sarlBehavior, superTypeRef, baseTypeRef)) {
				this.sarlBehavior.setExtends(superTypeRef);
				return;
			}
		}
		this.sarlBehavior.setExtends(null);
	}
12593
@Override
	public final SolrQuery doConstructSolrQuery(SolrDataQuery query, @Nullable Class<?> domainType) {

		Assert.notNull(query, "Cannot construct solrQuery from null value.");
		Assert.notNull(query.getCriteria(), "Query has to have a criteria.");

		SolrQuery solrQuery = new SolrQuery();
		solrQuery.setParam(CommonParams.Q, getQueryString(query, domainType));

		if (query instanceof Query) {
			processQueryOptions(solrQuery, (Query) query, domainType);
		}

		if (query instanceof FacetQuery) {
			processFacetOptions(solrQuery, (FacetQuery) query, domainType);
		}

		if (query instanceof HighlightQuery) {
			processHighlightOptions(solrQuery, (HighlightQuery) query, domainType);
		}

		return solrQuery;
	}
386544
public void setExtends(String superType) {
		if (!Strings.isEmpty(superType)
				&& !Event.class.getName().equals(superType)) {
			JvmParameterizedTypeReference superTypeRef = newTypeRef(this.sarlEvent, superType);
			JvmTypeReference baseTypeRef = findType(this.sarlEvent, Event.class.getCanonicalName());
			if (isSubTypeOf(this.sarlEvent, superTypeRef, baseTypeRef)) {
				this.sarlEvent.setExtends(superTypeRef);
				return;
			}
		}
		this.sarlEvent.setExtends(null);
	}
633543
def on_super( statement )
      arguments = process_all(statement.children)
      SendStatement.new( nil , SuperExpression.new , arguments)
    end
994088
public final void mSUPER() throws RecognitionException {
        try {
            int _type = SUPER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // org/javaruntype/type/parser/Type.g:36:7: ( ' super ' )
            // org/javaruntype/type/parser/Type.g:36:9: ' super '
            {
            match(" super "); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
896976
function(query,options) {
           for (var key in query) {
               if (query[key].$in) {
                   query[key]=query[key].$in;
               }
           }
           return this.inherited(arguments);
       }
279815
function _gpfClassSuperCreateWeakBoundWithSameSignature (that, $super, superMethod) {
    var definition = _gpfFunctionDescribe(superMethod);
    definition.body = "return _superMethod_.apply(this === _$super_ ? _that_ : this, arguments);";
    return _gpfFunctionBuild(definition, {
        _that_: that,
        _$super_: $super,
        _superMethod_: superMethod
    });
}
449074
@Override
    public Predicate gt(Expression<? extends Number> arg0, Expression<? extends Number> arg1)
    {
        // TODO Auto-generated method stub
        return null;
    }
361692
function(name) {
       if ($caller !== null) {
            for(var $s = $caller.boundTo.$parent; $s !== null; $s = $s.$parent) {
                var m = $s.prototype[name];
                if (typeof m === 'function') {
                    return m;
                }
            }
            return null;
        }
        throw new Error("$super is called outside of class context");
    }
894340
private void superSetProperty(String key, String oldValue)
    {
        if (oldValue != null) {
            super.setProperty(key, oldValue);
        }
    }
1116252
@Override
    public <T> TypedQuery<T> createQuery(CriteriaQuery<T> arg0) {
        try
        {
            return ivEm.createQuery(arg0);
        } finally
        {
            if (!inJTATransaction())
            {
                ivEm.clear();
            }
        }
    }