116:    
117:        public static function toReflection($callable): \ReflectionFunctionAbstract
118:        {
119:            if ($callable instanceof \Closure) {
120:                $callable = self::unwrap($callable);
121:            }
122:    
123:            if (is_string($callable) && strpos($callable, '::')) {
124:                return new \ReflectionMethod($callable);
125:            } elseif (is_array($callable)) {
126:                return new \ReflectionMethod($callable[0], $callable[1]);
127:            } elseif (is_object($callable) && !$callable instanceof \Closure) {
128:                return new \ReflectionMethod($callable, '__invoke');
129:            } else {
130:                return new \ReflectionFunction($callable);

103:            if (is_array($entity)) {
104:                if ($entity[0] instanceof Reference || $entity[0] instanceof Statement) {
105:                    $entity[0] = $this->resolveEntityType($entity[0] instanceof Statement ? $entity[0] : new Statement($entity[0]));
106:                    if (!$entity[0]) {
107:                        return null;
108:                    }
109:                }
110:    
111:                try {
112:                    /** @var \ReflectionMethod|\ReflectionFunction $reflection */
113:                    $reflection = Nette\Utils\Callback::toReflection($entity[0] === '' ? $entity[1] : $entity);
114:                    $refClass = $reflection instanceof \ReflectionMethod ? $reflection->getDeclaringClass() : null;
115:                } catch (\ReflectionException $e) {
116:                    $refClass = $reflection = null;
117:                }

171:    
172:        public function resolveType(Nette\DI\Resolver $resolver): void
173:        {
174:            if (!$this->getEntity()) {
175:                if (!$this->getType()) {
176:                    throw new ServiceCreationException('Factory and type are missing in definition of service.');
177:                }
178:                $this->setFactory($this->getType(), $this->factory->arguments ?? []);
179:    
180:            } elseif (!$this->getType()) {
181:                $type = $resolver->resolveEntityType($this->factory);
182:                if (!$type) {
183:                    throw new ServiceCreationException('Unknown service type, specify it or declare return type of factory.');
184:                }
185:                $this->setType($type);

60:        public function resolveDefinition(Definition $def): void
61:        {
62:            if ($this->recursive->contains($def)) {
63:                $names = array_map(function ($item) { return $item->getName(); }, iterator_to_array($this->recursive));
64:                throw new ServiceCreationException(sprintf('Circular reference detected for services: %s.', implode(', ', $names)));
65:            }
66:    
67:            try {
68:                $this->recursive->attach($def);
69:    
70:                $def->resolveType($this);
71:    
72:                if (!$def->getType()) {
73:                    throw new ServiceCreationException('Type of service is unknown.');
74:                }

280:         */
281:        public function resolve(): void
282:        {
283:            if ($this->resolving) {
284:                return;
285:            }
286:            $this->resolving = true;
287:    
288:            $resolver = new Resolver($this);
289:            foreach ($this->definitions as $def) {
290:                $resolver->resolveDefinition($def);
291:            }
292:    
293:            $this->autowiring->rebuild();
294:    

261:                return $processor->processMultiple($schema, $configs);
262:            } catch (Schema\ValidationException $e) {
263:                throw new Nette\DI\InvalidConfigurationException($e->getMessage());
264:            }
265:        }
266:    
267:    
268:        /** @internal */
269:        public function generateCode(): string
270:        {
271:            $this->builder->resolve();
272:    
273:            foreach ($this->extensions as $extension) {
274:                $extension->beforeCompile();
275:                $this->dependencies->add([(new \ReflectionClass($extension))->getFileName()]);

192:                assert($this->extensions[self::DI] instanceof Extensions\DIExtension);
193:                $this->extensions[self::DI]->exportedTypes[$type] = true;
194:            }
195:            return $this;
196:        }
197:    
198:    
199:        public function compile(): string
200:        {
201:            $this->processExtensions();
202:            return $this->generateCode();
203:        }
204:    
205:    
206:        /** @internal */

107:            }
108:            return false;
109:        }
110:    
111:    
112:        /** @return array of (code, file[]) */
113:        protected function generate(string $class, callable $generator): array
114:        {
115:            $compiler = new Compiler;
116:            $compiler->setClassName($class);
117:            $code = $generator(...[&$compiler]) ?: $compiler->compile();
118:            return [
119:                "<?php\n$code",
120:                serialize($compiler->exportDependencies()),
121:            ];

69:            if (!$handle) {
70:                throw new Nette\IOException("Unable to create file '$file.lock'. " . Nette\Utils\Helpers::getLastError());
71:            } elseif (!@flock($handle, LOCK_EX)) { // @ is escalated to exception
72:                throw new Nette\IOException("Unable to acquire exclusive lock on '$file.lock'. " . Nette\Utils\Helpers::getLastError());
73:            }
74:    
75:            if (!is_file($file) || $this->isExpired($file, $updatedMeta)) {
76:                if (isset($updatedMeta)) {
77:                    $toWrite["$file.meta"] = $updatedMeta;
78:                } else {
79:                    [$toWrite[$file], $toWrite["$file.meta"]] = $this->generate($class, $generator);
80:                }
81:    
82:                foreach ($toWrite as $name => $content) {
83:                    if (file_put_contents("$name.tmp", $content) !== strlen($content) || !rename("$name.tmp", $name)) {

34:    
35:    
36:        /**
37:         * @param  callable  $generator  function (Nette\DI\Compiler $compiler): string|null
38:         * @param  mixed  $key
39:         */
40:        public function load(callable $generator, $key = null): string
41:        {
42:            $class = $this->getClassName($key);
43:            if (!class_exists($class, false)) {
44:                $this->loadFile($class, $generator);
45:            }
46:            return $class;
47:        }
48:    

237:         * Loads system DI container class and returns its name.
238:         */
239:        public function loadContainer(): string
240:        {
241:            $loader = new DI\ContainerLoader(
242:                $this->getCacheDirectory() . '/nette.configurator',
243:                $this->parameters['debugMode']
244:            );
245:            $class = $loader->load(
246:                [$this, 'generateContainer'],
247:                [$this->parameters, array_keys($this->dynamicParameters), $this->configs, PHP_VERSION_ID - PHP_RELEASE_VERSION]
248:            );
249:            return $class;
250:        }
251:    

216:            $this->configs[] = $config;
217:            return $this;
218:        }
219:    
220:    
221:        /**
222:         * Returns system DI container.
223:         */
224:        public function createContainer(): DI\Container
225:        {
226:            $class = $this->loadContainer();
227:            $container = new $class($this->dynamicParameters);
228:            foreach ($this->services as $name => $service) {
229:                $container->addService($name, $service);
230:            }