text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>llNullOrIpv6($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function ipv6(string $value): string
{
Assert::ipv6($value);
return $value;
}
function nullOrIpv6(?string $value): ... | fim | webmozarts/assert | php |
<|fim_suffix|> allNullOrIsAOf(mixed $value): iterable
{
Assert::allNullOrIsAOf($value, Serializable::class);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Serializable;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @para... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param object|string $value
* @param array<class-string> $classes
*/
function isAnyOf(mixed $value, array $classes): object|string
{
Assert::isAnyOf($va... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tes<|fim_suffix|>ert\Assert;
/**
* @psalm-pure
*/
function isArray(mixed $value): array
{
Assert::isArray($value);
return $value;
}
/**
* @psalm-pure
*/
function nullOrIsArray(mixed $value): ?array
{
Assert::nullOrIsArray($valu... | fim | webmozarts/assert | php |
<|fim_suffix|>e($value);
return $value;
}
/**
* @psalm-pure
*/
function allNullOrIsArrayAccessible(mixed $value): iterable
{
Assert::allNullOrIsArrayAccessible($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use ArrayA... | fim | webmozarts/assert | php |
<|fim_suffix|>* @psalm-pure
*/
function allNullOrIsCallable(mixed $value): iterable
{
Assert::allNullOrIsCallable($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/*<|fim_middle|>*
* @psalm-pure
... | fim | webmozarts/assert | php |
<|fim_suffix|>salm-pure
*/
function nullOrIsCountable(mixed $value): ?Countable
{
Assert::nullOrIsCountable($value);
return $value;
}
/**
* @psalm-pure
*
* @return iterable<Countable>
*/
function allIsCountable(mixed $value)
{
Assert::allIsCountable($value);
return $value;
}
/**
* @psalm-pure
... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function isEmptyNullableObject(?object $value): null
{
Assert::isEmpty($value);
return $value;
}
/**
* @psalm-pure
*
* @return ""|"0"
*/
function ... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysi<|fim_suffix|>perty): object
{
Assert::isInitialized($value, $property);
return $value;
}
<|fim_middle|>s\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function isInitialized(mixed $value, string $pr... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Serializable;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function isInstanceOf(mixed $value): Serializable
{
Assert::isInstanceOf($value, Serializable::class);
return $value;
}
/**
* @psal... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @param object $value
* @param array<class-string> $classes
*/
function isInstanceOfAny(object $value, array $classes): object
{
Assert::isInstanceOfAny($value, $classes);... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\<|fim_suffix|>t\Assert;
/**
* @psalm-pure
*/
function isIterable(mixed $value): iterable
{
Assert::isIterable($value);
return $value;
}
/**
* @psalm-pure
*/
function nullOrIsIterable(mixed $value): ?iterable
{
Assert::nullOrIsIterable... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use stdClass;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return list<mixed>
*/
function isList(mix<|fim_suffix|>nction allIsList(mixed $value): iterable
{
Assert::allIsList($value);
return $... | fim | webmozarts/assert | php |
<|fim_suffix|>rray<mixed>> $value
*/
function allIsMap(iterable $value): iterable
{
Assert::allIsMap($value);
return $value;
}
/**
* @psalm-pure
*
* @param iterable<mixed|array<mixed>> $value
*/
function allNullOrIsMap(iterable $value): iterable
{
Assert::allNullOrIsMap($value);
return $value;
}... | fim | webmozarts/assert | php |
<|fim_suffix|>value;
}
/**
* @psalm-pure
*
* @param array<int> $value
*/
function isNonEmptyListWithRange(array $value): array
{
Assert::isNonEmptyList($value);
return $value;
}
/**
* @psalm-pure
*
* @return null|non-empty-list<mixed>
*/
function nullOrIsNonEmptyList(mixed $value): ?array
{
Asser... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use stdClass;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param array<string, mixed> $value
*
* @return non-empty-array<string, mixed>
*/
function isNonEmptyMap(array $value): array
{
Assert::isNonEmptyMap($v... | fim | webmozarts/assert | php |
<|fim_suffix|>lue
* @param class-string $class
*/
function allNullOrIsNotA(mixed $value, $class): iterable
{
Assert::allNullOrIsNotA($value, $class);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use DateTime;
use Webmozart\Assert\... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @param array<class-st<|fim_suffix|>m array<class-string> $classes
*/
function nullOrIsNotInstanceOfAny(mixed $value, array $classes): mixed
{
Assert::nullOrIsNotInstanceOf... | fim | webmozarts/assert | php |
<|fim_suffix|> $closure;
}
<|fim_prefix|><?php
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function is<|fim_middle|>Static(callable $closure): callable
{
Assert::isStatic($closure);
return<|endoftext|> | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param array-key $key
*/
function keyExists(array $array, $key): array
{
Assert::keyExists($array, $key);
return $array;
}
/**
* @psalm-pure
*
* @param array-... | fim | webmozarts/assert | php |
<|fim_suffix|>ray
{
Assert::nullOrKeyNotExists($array, $key);
return $array;
}
/**
* @psalm-pure
*
* @param iterable<array> $array
* @param array-key $key
*/
function allKeyNotExists(iterable $array, $key): iterable
{
Assert::allKeyNotExists($array, $key);
return $array;
}
/**
* @psalm-pure
*... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function length(string $value, int $length): string
{
Assert::length($value, $length);
return $value;
}
/**
* @psalm-pure
*/
function nullOrLength(?... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function lengthBetween(string $value, int $min, int $max): string
{
Assert::lengthBetween($value, $min, $max);
return $value;
}
/**
* @psalm-pure
*/... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
* @param mixed $limit
*/
function lessThan(mixed $value, mixed $limit): mixed
{
Assert::lessThan($value, $limit);
return $value;
}
/**
* @psalm-pure
*... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
* @param mixed $limit
*/
function lessThanEq(mixed $value, mixed $limit): mixed
{
Assert::lessThanEq($value, $limit);
return $value;
}
/**
* @psalm-pure
* @param mi... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return lowercase-string
*/
function lower(string $value): string
{
Assert::lower($value);
return $value;
}
/**
* @psalm-pure
*
* @return null|l... | fim | webmozarts/assert | php |
<|fim_suffix|>y|null> $array
* @param int|float $max
*/
function allNullOrMaxCount(iterable $array, $max): iterable
{
Assert::allNullOrMaxCount($array, $max);
return $array;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Countable;
use Webmoza... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function maxLength(string $value, int $max): string
{
Assert::maxLength($value, $max);
return $value;
}
/**
* @psalm-pure
*/
function nullOrMaxLengt... | fim | webmozarts/assert | php |
<|fim_suffix|>
* @param mixed $method
*/
function methodExists(mixed $classOrObject, $method): string|object
{
Assert::methodExists($classOrObject, $method);
return $classOrObject;
}
/**
* @psalm-pure
*
* @param null|class-string|object $classOrObject
* @param mixed $method
*/
function nullOrMethodExis... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(str<|fim_suffix|>ert::methodNotExists($classOrObject, $method);
return $classOrObject;
}
/**
* @psalm-pure
*
* @param null|class-string|object $classOrObject
* @param mixed $method
*/
function nullOrMethodNotExists(mixed $classOrObject, $method): string|object|null
{
Assert::... | fim | webmozarts/assert | php |
<|fim_suffix|>tion allNullOrMinCount(mixed $array, $min)
{
Assert::allNullOrMinCount($array, $min);
return $array;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Countable;
use Webmozart\Assert\Assert;
/**
* @param Countable|array $array
* @p... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param int|float $min
*/
function minLength(string $value, $min): string
{
Assert::minLength($value, $min);
return $value;
}
/**
* @psalm-pure
*
... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @psalm-return positive-int|0
*/
function natural(mixed $value): int
{
Assert::natural($value);
return $value;
}
/**
* @psalm-pure
*
* @psalm-ret... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @psalm-return negative-int
*/
function negativeInteger(mixed $value): int
{
Assert::negativeInteger($value);
r<|fim_suffix|>alm-pure
*
* @return i... | fim | webmozarts/assert | php |
<|fim_suffix|>ing $subString): iterable
{
Assert::allNullOrNotContains($value, $subString);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function notContains(string $value, string... | fim | webmozarts/assert | php |
<|fim_suffix|>
}
/**
* @psalm-pure
*/
function allNullOrNotEmpty(mixed $value): mixed
{
Assert::allNullOrNotEmpty($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function notEndsWith(string $value, string $suffix): string
{
Assert::notEndsWith($value, $suffix);
return $valu<|fim_suffix|>value, $suffix);
ret... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\A<|fim_suffix|>): mixed
{
Assert::allNullOrNotEq($value, $expect);
return $value;
}
<|fim_middle|>ssert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function notEq(mixed $value, mixed $expect): mixed
{
Assert::notEq($value... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return true
*/
function notFalseBool(bool $value): bool
{
Assert::notFalse($value);
return $value;
}
/**
* @psalm-pure
*
* @param false|string $value
*/
fun... | fim | webmozarts/assert | php |
<|fim_suffix|>ue, $values);
return $value;
}
/**
* @psalm-pure
*/
function allNotInArray(mixed $value, array $values): mixed
{
Assert::allNotInArray($value, $values);
return $value;
}
<|fim_prefix|><?php
namesp<|fim_middle|>ace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Ass... | fim | webmozarts/assert | php |
<|fim_suffix|>e Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use stdClass;
use Webmozart\Assert\Assert;
function notInstanceOf(mixed $value): object
{
Assert::notInstanceOf($value, stdClass::class);
return $value;
}
/**
* @psalm-template T of object
* @param class-string<T> $class
*/
function nullOrN... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @psalm-return non-negative-int
*/
function nonNegativeInteger(mixed $value): int
{
Assert::notNegativeInteger($value);
return $value;
}
/**
* @psa... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\<|fim_suffix|>otNull($value);
return $value;
}
/**
* @psalm-pure
*
* @param iterable<mixed|null> $value
*/
function allNotNull(iterable $value): iterable
{
Assert::allNotNull($value);
return $value;
}
/**
* @psalm-pure
*
* ... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function notOneOf(mixed $value, array $values): mixed
{
Assert::notOneOf($value, $values);
return $value;
}
/**
* @psalm-pure
*/
function nullOrNotOneOf(mixed $value, array $... | fim | webmozarts/assert | php |
<|fim_suffix|>ull> $value
*/
function allNullOrNotRegex(iterable $value, string $pattern): iterable
{
Assert::allNotRegex($value, $pattern);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/<|fim_middle|>... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webm<|fim_suffix|>Same(mixed $value, $expect): mixed
{
Assert::notSame($value, $expect);
return $value;
}
/**
* @psalm-pure
* @param mixed $expect
*/
function nullOrNotSame(mixed $value, $expect):... | fim | webmozarts/assert | php |
<|fim_suffix|>StartsWith(iterable $value, string $prefix): iterable
{
Assert::allNotStartsWith($value, $prefix);
return $value;
}
/**
* @psalm-pure
*
* @param iterable<string|null> $value
*/
function allNullOrNotStartsWith(iterable $value, string $prefix): iterable
{
Assert::allNullOrNotStartsWith($va... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function notStatic(callable $closure): callable
{
Assert::n<|fim_suffix|>($closure);
return $closure;
}
<|fim_middle|>otStatic<|endoftext|> | fim | webmozarts/assert | php |
<|fim_suffix|>sert::allNullOrNotWhitespaceOnly($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function n<|fim_middle|>otWhitespaceOnly(string $value): string
{
Assert::notW... | fim | webmozarts/assert | php |
<|fim_suffix|>eturn $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function null(mixed $value): nu<|fim_middle|>ll
{
Assert::null($value);
return $value;
}
/**
* @psalm-pure
*/
function... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_typ<|fim_suffix|> Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return numeric
*/
function numeric(mixed $value)
{
Assert::numeric($value);
return $value;
}
/**
* @psalm-pure
*
* @return null|numeric
*/
functi... | fim | webmozarts/assert | php |
<|fim_suffix|>ixed $value): iterable
{
Assert::allObject($value);
return $value;
}
/**
* @psalm-pure
*/
function allNullOrObject(mixed $value): iterable
{
Assert::allNullOrObject($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
<|fim_suffix|>ed $value): iterable
{
Assert::allObjectish($value);
return $value;
}
/**
* @psalm-pure
*/
function allNullOrObjectish(mixed $value): iterable
{
Ass... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function oneOf(mixed $value, array $values): mixed
{
Assert::oneOf($value, $values);
return $value;
}
/**
* @psalm-pure
*/
function nullOrOneOf(mixed $value, arra... | fim | webmozarts/assert | php |
<|fim_suffix|>lPositiveInteger($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @psalm-return positive-int
*/
function positiveInteger(mixed $value): int
{
Assert::positiv... | fim | webmozarts/assert | php |
<|fim_suffix|>iterable
{
Assert::allPropertyExists($classOrObject, $property);
return $classOrObject;
}
/**
* @psalm-pure
*
* @param iterable<class-string|object|null> $classOrObject
* @param mixed $property
*/
function allNullOrPropertyExists(iterable $classOrObject, $property): iterable
{
Assert::a... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param class-string|object $classOrObject
* @param mixed $property
*/
function propertyNotExists(mixed $classOrObject, $property): string|object
{
Asser... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @see https://github.com/webmozart/assert/pull/160#issuecomment-564491986
* @see https://github.com/vimeo/psalm/commit/4b715cdbffea19a7eab6f72482027d2dd358aab2
* @see http... | fim | webmozarts/assert | php |
<|fim_suffix|>/
function returnedNumeric(mixed $value): int|float|string
{
Assert::numeric($value);
return $value;
}
/**
* @psalm-pure
*
* @return numeric
*/
function returnedIntegerish(mixed $value): int|float|string
{
Assert::integerish($value);
return $value;
}
<|fim_prefix|><?php
<|fim_middl... | fim | webmozarts/assert | php |
<|fim_suffix|>inerAllArrayIterator(mixed $value)
{
Assert::allString($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use ArrayIterator;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @par<|fim_middle|>am mixed[] $value... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(st<|fim_suffix|>ct_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @param non-empty-string $value
*
* @return non-empty-string
*/
function lowerPreservesTypes(string $value): string
{
Assert::lower($value);... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
* @param mixed $min
* @param mixed $max
*/
function range(mixed $value, $min, $max): mixed
{
Assert::range($value, $min, $max);
return $value;
}
/**
* @psalm-pure
... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function readable(string $value): string
{
Assert::readable($value);
return $value;
}
function nullOrReadable(?string $value): ?string
{
Assert::nullOrReadable($value);
... | fim | webmozarts/assert | php |
<?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function regex(string $value, string $pattern): string
{
Assert::regex($value, $pattern);
return $value;
}
/**
* @psalm-pure
*/
function nullOrRegex(?string $valu... | fim | webmozarts/assert | php |
<|fim_suffix|>**
* @psalm-pure
* @param null|string $type
*/
function resource(mixed $value, ?string $type): mixed
{
Assert::resource($value, $type);
return $value;
}
/**
* @psalm-pure
* @param null|string $type
*/
function nullOrResource(mixed $value, ?string $type): mixed
{
Assert::nullOrResource(... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
* @param mixed $expect
*/
function same(mixed $value, $expect): mixed
{
Assert::same($value, $expect);
return $value;
}
/**
* @psalm-pure
* @param mix... | fim | webmozarts/assert | php |
<|fim_suffix|> allNullOrScalar(mixed $value): iterable
{
Assert::allNullOrScalar($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function scalar(mixed $value): int|float|str... | fim | webmozarts/assert | php |
<|fim_suffix|>function startsWith(string $value, string $prefix): string
{
Assert::startsWith($value, $prefix);
return $value;
}
/**
* @psalm-pure
*/
function nullOrStartsWith(?string $value, string $prefix): ?string
{
Assert::nullOrStartsWith($value, $prefix);
return $value;
}
/**
* @psalm-pure
... | fim | webmozarts/assert | php |
<|fim_suffix|>alue, $prefix);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function startsWithLetter(mixed $value, string $prefix): mixed
{
Assert::startsWithLetter($value, $prefi... | fim | webmozarts/assert | php |
<|fim_suffix|>:nullOrString($value);
return $value;
}
/**
* @psalm-pure
*/
function allString(mixed $value): iterable
{
Assert::allString($value);
return $value;
}
/**
* @psalm-pure
*/
function allNullOrString(mixed $value): iterable
{
Assert::allNullOrString($value);
return $value;
}
<|fim... | fim | webmozarts/assert | php |
<|fim_suffix|>otEmpty(mixed $value): iterable
{
Assert::allNullOrStringNotEmpty($value);
return $value;
}
<|fim_prefix|><?p<|fim_middle|>hp
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return non-empty-string
*/
... | fim | webmozarts/assert | php |
<|fim_suffix|>s-string<stdClass>|stdClass
*/
function subclassOf(mixed $value)
{
Assert::subclassOf($value, stdClass::class);
return $value;
}
/**
* @psalm-pure
*
* @return null|class-string<stdClass>|stdClass
*/
function nullOrSubclassOf(mixed $value)
{
Assert::nullOrSubclassOf($value, stdClass::cla... | fim | webmozarts/assert | php |
<|fim_suffix|>value, $class);
return $value;
}
/**
* @param iterable<Closure|null> $value
* @param class-string<Throwable> $class
*/
function allNullOrThrows(iterable $value, $class): iterable
{
Assert::allNullOrThrows($value, $class);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
nam... | fim | webmozarts/assert | php |
<|fim_suffix|>lue): iterable
{
Assert::allNullOrTrue($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*
* @return true
*/
function true(mixed $value): bool
{
Assert::true(... | fim | webmozarts/assert | php |
<|fim_suffix|>}
/**
* @psalm-pure
*/
function allNullOrUnicodeLetters(mixed $value): mixed
{
Assert::allNullOrUnicodeLetters($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\As<|fim_middle|>sert\Assert;
/**
*... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Assert\Assert;
function uniqueValues(mixed $values): array
{
Assert::uniqueVal<|fim_suffix|>@return iterable<array>
*/
function allUniqueValues(iterable $values): iterable
{
Assert::allUniq... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalys<|fim_suffix|>rn $value;
}
<|fim_middle|>is\NonReturn;
use Webmozart\Assert\Assert;
/**
* @psalm-pure
*/
function upper(mixed $value): string
{
Assert::upper($value);
return $value;
}
/**
* @psalm-pure
*/
functio... | fim | webmozarts/assert | php |
<|fim_suffix|>
/**
* @psalm-pure
*
* @param iterable<string|null> $value
*/
function allNullOrUuid(iterable $value): iterable
{
Assert::allNullOrUuid($value);
return $value;
}
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\StaticAnalysis\NonReturn;
use Webmozart\Ass<|fim_... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webm<|fim_suffix|>value): iterable
{
Assert::allValidArrayKey($value);
return $value;
}
/**
* @psalm-pure
*/
function allNullOrValidArrayKey(mixed $value): iterable
{
Assert::allNullOrValidArrayKey($value);
return $value;
}
<|fim_middle|>ozar... | fim | webmozarts/assert | php |
<|fim_prefix|><?php
declare(strict_types=1);
namespace Webmozart\Assert\Tests\Stat<|fim_suffix|>
return $value;
}
/**
* @param iterable<string> $value
*/
function allWritable(iterable $value): iterable
{
Assert::allWritable($value);
return $value;
}
/**
* @param iterable<string|null> $value
*/
func... | fim | webmozarts/assert | php |
<|fim_prefix|>import { getInfo, getInfoFromPullRequest } from "@changesets/get-github-info";
/** @typedef {import("@changesets/types").ChangelogFunctions} ChangelogFunctions */
/**
* @returns {{ GITHUB_SERVER_URL: string }} value
*/
function readEnv() {
const GITHUB_SERVER_URL =
process.env.GITHUB_SERVER_URL || ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import fs from "fs/promises";
import path from "path";
import { fileURLToPath } from "url";
import { simpleGit } from "simple-git";
import pkgJson from "../package.json" with { type: "json" };
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const rootPath = path.join(__dirname, "..");
con... | fim | webpack/webpack | javascript |
/* eslint-disable no-console */
/* eslint-disable camelcase */
import fs from "fs";
/**
* @param {{ github: EXPECTED_ANY, context: EXPECTED_ANY }} params params
*/
export async function run({ github, context }) {
const output = JSON.parse(fs.readFileSync("output.json", "utf8"));
const sha =
context.eventName =... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
printWidth: 80,
us<|fim_suffix|>ts,ts}",
options: {
parser: "typescript"
}
}
]
};
<|fim_middle|>eTabs: true,
tabWidth: 2,
trailingComma: "none",
arrowParens: "always",
overrides: [
{
files: "*.json",
options: {
parser: "json",
useTabs: f... | fim | webpack/webpack | javascript |
/*
** ********************************************************************
** md4.c -- Implementation of MD4 Message Digest Algorithm **
** Updated: 2/16/90 by Ronald L. Rivest **
** (C) 1990 RSA Data Security, Inc. **
** *********************... | fim | webpack/webpack | typescript |
<|fim_suffix|>left ? => eat 8 bytes per step
for (; dataPtr + 8 <= length; dataPtr += 8) {
result =
rotl(result ^ processSingle(0, load<u64>(dataPtr)), 27) * Prime1 + Prime4;
}
// 4 bytes left ? => eat those
if (dataPtr + 4 <= length) {
result = rotl(result ^ (load<u32>(dataPtr) * Prime1), 23) * Prime2 + Pr... | fim | webpack/webpack | typescript |
<|fim_suffix|>cli.package]
)
.then(() => {
runCli(cli);
})
.catch((err) => {
console.error(err);
process.exitCode = 1;
});
});
} else {
runCli(cli);
}
<|fim_prefix|>#!/usr/bin/env node
"use strict";
/**
* @param {string} command process to run
* @param {string[]} args command line argume... | fim | webpack/webpack | javascript |
import type { RawSourceMap } from "../lib/NormalModule";
import type Module from "../lib/Module";
import type { validate } from "schema-utils";
import type { AssetInfo } from "../lib/Compilation";
import type { ResolveOptionsWithDependencyType } from "../lib/ResolverFactory";
import type Compilation from "../lib/Compil... | fim | webpack/webpack | typescript |
export type {
LoaderModule,
RawLoaderDefinition,
LoaderDefinition,
LoaderDefinitionFunction,
PitchLoaderDefinitionFunction,
RawLoaderDefinitionFunction,
LoaderContext
} from "./LoaderContext";
<|endoftext|> | fim | webpack/webpack | typescript |
<|fim_suffix|>*/
entryOnly?: boolean;
/**
* Exclude all modules matching any of these conditions.
*/
exclude?: Rules;
/**
* If true, banner will be placed at the end of the output.
*/
footer?: boolean;
/**
* Include all modules matching any of these conditions.
*/
include?: Rules;
/**
* If true, b... | fim | webpack/webpack | typescript |
/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
export type IgnorePluginOptions =
| {
/**
* A RegExp to test the context (directory) against.
*/
contextRegExp?: RegExp;
/**
* A RegExp to test the request against.
*/
resourceReg... | fim | webpack/webpack | typescript |
<|fim_suffix|>A configuration object that can be used to configure older loaders.
*/
options?: {
/**
* The context that can be used to configure older loaders.
*/
context?: string;
[k: string]: any;
};
[k: string]: any;
}
<|fim_prefix|>/*
* This file was automatically generated.
* DO NOT MODIFY BY HA... | fim | webpack/webpack | typescript |
/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
export interface ManifestPluginOptions {
/**
* Enables/disables generation of the entrypoints manifest section.
*/
entrypoints?: boolean;
/**
* Specifies the filename of the output file on disk. By d... | fim | webpack/webpack | typescript |
<|fim_prefix|>/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
export type ProgressPluginArgument = ProgressPluginOptions | HandlerFunction;
/**
* Function that executes for every progress step.
*/
export type HandlerFunction = import("../../lib/ProgressP... | fim | webpack/webpack | typescript |
<|fim_suffix|>allbackModuleFilenameTemplate?:
| string
| import("../../lib/ModuleFilenameHelpers").ModuleFilenameTemplateFunction;
/**
* Path prefix to which the [file] placeholder is relative to.
*/
fileContext?: string;
/**
* Defines the output filename of the SourceMap (will be inlined if no value is pr... | fim | webpack/webpack | typescript |
<|fim_suffix|>ld be ignored.
*/
paths: (RegExp | string)[];
}
<|fim_prefix|>/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
export interface WatchIgnorePluginOptions {
/**
* A list of RegExps or absolute paths to directories or f<|fim_middle|>iles th... | fim | webpack/webpack | typescript |
<|fim_suffix|>xposed commonjs export in the UMD.
*/
commonjs?: string;
/**
* Name of the property exposed globally by a UMD library.
*/
root?: string[] | string;
}
<|fim_prefix|>/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
/**
* Modules that s... | fim | webpack/webpack | typescript |
<|fim_suffix|>hould be resolved and loaded at runtime.
*/
export interface RemotesConfig {
/**
* Container locations from which modules should be resolved and loaded at runtime.
*/
external: RemotesItem | RemotesItems;
/**
* The name of the share scope shared with this remote.
*/
shareScope?: string;
}
<|f... | fim | webpack/webpack | typescript |
/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
/**
* Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
*/
export type Exposes = (ExposesIt... | fim | webpack/webpack | typescript |
<|fim_suffix|>aults to `events.json`.
*/
outputPath?: string;
}
<|fim_prefix|>/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn fix:special` to update
*/
export interface ProfilingPluginOptions {
/**
* Path to <|fim_middle|>the output file e.g. `path.resolve(__dirname, 'profili... | fim | webpack/webpack | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.