Returns true if provenance of property is SPE or AST
490063
def use_property(kepid, prop):
    
    try:
        prov = kicu.DATA.ix[kepid, '{}_prov'.format(prop)]
        return any([prov.startswith(s) for s in ['SPE', 'AST']])
    except KeyError:
        raise MissingStellarError('{} not in stellar table?'.format(kepid))
1073160
static boolean isGetOrSetKey(Node node) {
    switch (node.getToken()) {
      case GETTER_DEF:
      case SETTER_DEF:
        return true;
      case COMPUTED_PROP:
        return node.getBooleanProp(Node.COMPUTED_PROP_GETTER)
            || node.getBooleanProp(Node.COMPUTED_PROP_SETTER);
      default:
        break;
    }
    return false;
  }
968861
boolean matchSourcePropertyType(String destination) {
    for (Tokens tokens: propertyNameInfo.getSourcePropertyTypeTokens())
      for (String token: tokens)
        if (token.equalsIgnoreCase(destination))
          return true;
    return false;
  }
210343
def _value_properties_are_referenced(val):
    
    if ((u'properties' in val.keys()) and
            (u'$ref' in val['properties'].keys())):
        return True
    return False
1219808
function TSPropertySignatureToProperty(node, type = "Property") {
            return {
                type,
                key: node.key,
                value: node.value || node.typeAnnotation,

                // Property flags
                computed: false,
                method: false,
                kind: "init",
                // this will stop eslint from interrogating the type literal
                shorthand: true,

                // location data
                parent: node.parent,
                range: node.range,
                loc: node.loc,
            };
        }
905241
function isPropertyOrKey(path) {
  return path.parentPath.get('key') === path || path.parentPath.get('property') === path;
}
564949
public boolean isMetBy(GlobalProperties props) {
		if (this.partitioning == PartitioningProperty.ANY_DISTRIBUTION) {
			return true;
		} else if (this.partitioning == PartitioningProperty.FULL_REPLICATION) {
			return props.isFullyReplicated();
		}
		else if (props.isFullyReplicated()) {
			return false;
		}
		else if (this.partitioning == PartitioningProperty.RANDOM_PARTITIONED) {
			return true;
		}
		else if (this.partitioning == PartitioningProperty.ANY_PARTITIONING) {
			return checkCompatiblePartitioningFields(props);
		}
		else if (this.partitioning == PartitioningProperty.HASH_PARTITIONED) {
			return props.getPartitioning() == PartitioningProperty.HASH_PARTITIONED &&
					checkCompatiblePartitioningFields(props);
		}
		else if (this.partitioning == PartitioningProperty.RANGE_PARTITIONED) {
			return props.getPartitioning() == PartitioningProperty.RANGE_PARTITIONED &&
					props.matchesOrderedPartitioning(this.ordering);
		}
		else if (this.partitioning == PartitioningProperty.FORCED_REBALANCED) {
			return props.getPartitioning() == PartitioningProperty.FORCED_REBALANCED;
		}
		else if (this.partitioning == PartitioningProperty.CUSTOM_PARTITIONING) {
			return props.getPartitioning() == PartitioningProperty.CUSTOM_PARTITIONING &&
					checkCompatiblePartitioningFields(props) &&
					props.getCustomPartitioner().equals(this.customPartitioner);

		}
		else {
			throw new CompilerException("Properties matching logic leaves open cases.");
		}
	}
963488
private boolean isDescriptorProperty(Object property) {

        return (getBundleType().equals(BundleType.DESCRIPTOR)
            || (hasDescriptor()
                && (property.equals(TableProperty.KEY)
                    || property.equals(TableProperty.DEFAULT)
                    || property.equals(TableProperty.DESCRIPTION))));
    }
1042919
public boolean isSet(String propName) {
        if (propName.equals("method")) {
            return isSetMethod();
        }
        if (propName.equals("object")) {
            return isSetObject();
        }
        if (propName.equals("attribute")) {
            return isSetAttribute();
        }
        return false;
    }
1156133
def has_property(self, property_name):
        
        if property_name in self.properties:
            return True
        elif property_name in self.entities:
            return True
        elif property_name in self.collections:
            return True
        else:
            return False
1259822
public boolean isSupported(TypeDesc propertyType) {
        if (propertyType.toPrimitiveType() != null) {
            return true;
        }
        if (propertyType == TypeDesc.STRING || propertyType == TypeDesc.forClass(byte[].class)) {
            return true;
        }
        Class clazz = propertyType.toClass();
        if (clazz != null) {
            return Lob.class.isAssignableFrom(clazz) ||
                BigInteger.class.isAssignableFrom(clazz) ||
                BigDecimal.class.isAssignableFrom(clazz);
        }
        return false;
    }
30750
function findPropertyWithValidDescription(type, propertyName) {
    type = findTypeMetaInfo(type);
    if (!type) {
        return '';
    }
    var property = mergeProperties(type).find(p => p.name === propertyName && !!p.description);
    if (property) {
        return property.description;
    }

    var parents = (type.implements || []).concat();
    if (type.extends) {
        parents.push(type.extends);
    }
    for (var i = 0; i < parents.length; i++) {
        var propertyDesc = findPropertyWithValidDescription(parents[i], propertyName);
        if (propertyDesc) {
            return propertyDesc;
        }
    }
    return '';
}
1036665
def is_none(entity, prop, name):
    ""
    return is_not_empty(entity, prop, name) and getattr(entity, name) is None
439616
@Override
    public boolean isSet(String propName) {
        if (propName.equals("checkPoint")) {
            return isSetCheckPoint();
        }
        if (propName.equals("changeTypes")) {
            return isSetChangeTypes();
        }
        return super.isSet(propName);
    }
57848
private static boolean isPropertyTree(Node expectedGetprop) {
    if (!expectedGetprop.isGetProp()) {
      return false;
    }

    Node leftChild = expectedGetprop.getFirstChild();
    if (!leftChild.isThis() && !isPropertyTree(leftChild)) {
      return false;
    }

    Node retVal = leftChild.getNext();
    return NodeUtil.getStringValue(retVal) != null;
  }
70853
def is_false(entity, prop, name):
    ""
    return is_not_empty(entity, prop, name) and name in entity._data and not bool(getattr(entity, name))
719745
private boolean hasOverriddenNativeProperty(String propertyName) {
    if (isNativeObjectType()) {
      return false;
    }

    JSType propertyType = getPropertyType(propertyName);
    ObjectType nativeType =
        isFunctionType()
            ? registry.getNativeObjectType(JSTypeNative.FUNCTION_PROTOTYPE)
            : registry.getNativeObjectType(JSTypeNative.OBJECT_PROTOTYPE);
    JSType nativePropertyType = nativeType.getPropertyType(propertyName);
    return propertyType != nativePropertyType;
  }