← Back to branch summary

~ubuntu-branches/debian/experimental/nuitka/experimental

« back to all changes in this revision

Viewing changes to nuitka/tree/ReformulationClasses.py

  • Committer: Package Import Robot
  • Author(s): Kay Hayen
  • Date: 2014-10-05 19:28:20 UTC
  • mfrom: (1.1.30)
  • Revision ID: package-import@ubuntu.com-20141005192820-s06oca9rty517iy8
Tags: 0.5.5+ds-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nuitka/tree/ReformulationClasses.py
49
49
    ExpressionFunctionBody,
50
50
    ExpressionFunctionCall,
51
51
    ExpressionFunctionCreation,
 
52
    ExpressionFunctionQualnameRef,
52
53
    ExpressionFunctionRef
53
54
)
54
55
from nuitka.nodes.GlobalsLocalsNodes import (
157
158
    statements = [
158
159
        StatementSetLocals(
159
160
            new_locals = ExpressionTempVariableRef(
160
 
                variable   = tmp_prepared.makeReference(provider),
 
161
                variable   = tmp_prepared,
161
162
                source_ref = source_ref
162
163
            ),
163
164
            source_ref = source_ref
205
206
            "__qualname__"
206
207
        )
207
208
 
 
209
        if Utils.python_version < 340:
 
210
            qualname_ref = ExpressionConstantRef(
 
211
                constant      = qualname,
 
212
                source_ref    = source_ref,
 
213
                user_provided = True
 
214
            )
 
215
        else:
 
216
            qualname_ref = ExpressionFunctionQualnameRef(
 
217
                function_body = class_creation_function,
 
218
                source_ref    = source_ref,
 
219
            )
 
220
 
208
221
        statements.append(
209
222
            StatementAssignmentVariable(
210
223
                variable_ref = ExpressionTargetVariableRef(
212
225
                    variable      = qualname_variable,
213
226
                    source_ref    = source_ref
214
227
                ),
215
 
                source        = ExpressionConstantRef(
216
 
                    constant      = qualname,
217
 
                    source_ref    = source_ref,
218
 
                    user_provided = True
219
 
                ),
 
228
                source       = qualname_ref,
220
229
                source_ref   = source_ref
221
230
            )
222
231
        )
223
232
 
 
233
        if Utils.python_version >= 340:
 
234
            qualname_assign = statements[-1]
 
235
 
224
236
    if Utils.python_version >= 340 and False: # TODO: Temporarily reverted:
225
237
        tmp_class = class_creation_function.allocateTempVariable(
226
238
            temp_scope = None,
228
240
        )
229
241
 
230
242
        class_target_variable_ref = ExpressionTargetTempVariableRef(
231
 
            variable   = tmp_class.makeReference(class_creation_function),
 
243
            variable   = tmp_class,
232
244
            source_ref = source_ref
233
245
        )
234
246
        class_variable_ref = ExpressionTempVariableRef(
235
 
            variable   = tmp_class.makeReference(class_creation_function),
 
247
            variable   = tmp_class,
236
248
            source_ref = source_ref
237
249
        )
238
250
    else:
257
269
            variable_ref = class_target_variable_ref,
258
270
            source       = ExpressionCall(
259
271
                called     = ExpressionTempVariableRef(
260
 
                    variable   = tmp_metaclass.makeReference(provider),
 
272
                    variable   = tmp_metaclass,
261
273
                    source_ref = source_ref
262
274
                ),
263
275
                args       = makeSequenceCreationOrConstant(
269
281
                            user_provided = True
270
282
                        ),
271
283
                        ExpressionTempVariableRef(
272
 
                            variable   = tmp_bases.makeReference(provider),
 
284
                            variable   = tmp_bases,
273
285
                            source_ref = source_ref
274
286
                        ),
275
287
                        ExpressionBuiltinLocals(
279
291
                    source_ref    = source_ref
280
292
                ),
281
293
                kw         = ExpressionTempVariableRef(
282
 
                    variable   = tmp_class_decl_dict.makeReference(provider),
 
294
                    variable   = tmp_class_decl_dict,
283
295
                    source_ref = source_ref
284
296
                ),
285
297
                source_ref = source_ref
341
353
    statements = (
342
354
        StatementAssignmentVariable(
343
355
            variable_ref = ExpressionTargetTempVariableRef(
344
 
                variable   = tmp_bases.makeReference( provider ),
 
356
                variable   = tmp_bases,
345
357
                source_ref = source_ref
346
358
            ),
347
359
            source       = makeSequenceCreationOrConstant(
355
367
        ),
356
368
        StatementAssignmentVariable(
357
369
            variable_ref = ExpressionTargetTempVariableRef(
358
 
                variable   = tmp_class_decl_dict.makeReference(provider),
 
370
                variable   = tmp_class_decl_dict,
359
371
                source_ref = source_ref
360
372
            ),
361
373
            source       = makeDictCreationOrConstant(
380
392
        ),
381
393
        StatementAssignmentVariable(
382
394
            variable_ref = ExpressionTargetTempVariableRef(
383
 
                variable   = tmp_metaclass.makeReference(provider),
 
395
                variable   = tmp_metaclass,
384
396
                source_ref = source_ref
385
397
            ),
386
398
            source       = ExpressionSelectMetaclass(
393
405
                            user_provided = True
394
406
                        ),
395
407
                        right      = ExpressionTempVariableRef(
396
 
                            variable   = tmp_class_decl_dict.makeReference(
397
 
                                provider
398
 
                            ),
 
408
                            variable   = tmp_class_decl_dict,
399
409
                            source_ref = source_ref
400
410
                        ),
401
411
                        source_ref = source_ref
402
412
                    ),
403
413
                    yes_expression = ExpressionDictOperationGet(
404
414
                        dicte      = ExpressionTempVariableRef(
405
 
                            variable   = tmp_class_decl_dict.makeReference(
406
 
                                provider
407
 
                            ),
 
415
                            variable   = tmp_class_decl_dict,
408
416
                            source_ref = source_ref
409
417
                        ),
410
418
                        key        = ExpressionConstantRef(
416
424
                    ),
417
425
                    no_expression  = ExpressionConditional(
418
426
                        condition      = ExpressionTempVariableRef(
419
 
                            variable   = tmp_bases.makeReference(provider),
 
427
                            variable   = tmp_bases,
420
428
                            source_ref = source_ref
421
429
                        ),
422
430
                        no_expression  = ExpressionBuiltinRef(
426
434
                        yes_expression = ExpressionBuiltinType1(
427
435
                            value      = ExpressionSubscriptLookup(
428
436
                                expression = ExpressionTempVariableRef(
429
 
                                    variable   = tmp_bases.makeReference(
430
 
                                        provider
431
 
                                    ),
 
437
                                    variable   = tmp_bases,
432
438
                                    source_ref = source_ref
433
439
                                ),
434
440
                                subscript  = ExpressionConstantRef(
445
451
                    source_ref     = source_ref
446
452
                ),
447
453
                bases     = ExpressionTempVariableRef(
448
 
                    variable   = tmp_bases.makeReference(provider),
 
454
                    variable   = tmp_bases,
449
455
                    source_ref = source_ref
450
456
                ),
451
457
                source_ref = source_ref
461
467
                    user_provided = True
462
468
                ),
463
469
                right      = ExpressionTempVariableRef(
464
 
                    variable   = tmp_class_decl_dict.makeReference(
465
 
                        provider
466
 
                    ),
 
470
                    variable   = tmp_class_decl_dict,
467
471
                    source_ref = source_ref
468
472
                ),
469
473
                source_ref = source_ref
472
476
            yes_branch = makeStatementsSequenceFromStatement(
473
477
                statement = StatementDictOperationRemove(
474
478
                    dicte = ExpressionTempVariableRef(
475
 
                        variable   = tmp_class_decl_dict.makeReference(
476
 
                            provider
477
 
                        ),
 
479
                        variable   = tmp_class_decl_dict,
478
480
                        source_ref = source_ref
479
481
                    ),
480
482
                    key   = ExpressionConstantRef(
489
491
        ),
490
492
        StatementAssignmentVariable(
491
493
            variable_ref = ExpressionTargetTempVariableRef(
492
 
                variable   = tmp_prepared.makeReference(
493
 
                    provider
494
 
                ),
 
494
                variable   = tmp_prepared,
495
495
                source_ref = source_ref
496
496
            ),
497
497
            source       = ExpressionConditional(
498
498
                condition = ExpressionBuiltinHasattr(
499
499
                    object     = ExpressionTempVariableRef(
500
 
                        variable   = tmp_metaclass.makeReference(
501
 
                            provider
502
 
                        ),
 
500
                        variable   = tmp_metaclass,
503
501
                        source_ref = source_ref
504
502
                    ),
505
503
                    name       = ExpressionConstantRef(
517
515
                yes_expression = ExpressionCall(
518
516
                    called     = ExpressionAttributeLookup(
519
517
                        expression     = ExpressionTempVariableRef(
520
 
                            variable   = tmp_metaclass.makeReference(
521
 
                                provider
522
 
                            ),
 
518
                            variable   = tmp_metaclass,
523
519
                            source_ref = source_ref
524
520
                        ),
525
521
                        attribute_name = "__prepare__",
533
529
                                user_provided = True
534
530
                            ),
535
531
                            ExpressionTempVariableRef(
536
 
                                variable   = tmp_bases.makeReference(
537
 
                                    provider
538
 
                                ),
 
532
                                variable   = tmp_bases,
539
533
                                source_ref = source_ref
540
534
                            )
541
535
                        ),
542
536
                        source_ref = source_ref
543
537
                    ),
544
538
                    kw         = ExpressionTempVariableRef(
545
 
                        variable   = tmp_class_decl_dict.makeReference(
546
 
                            provider
547
 
                        ),
 
539
                        variable   = tmp_class_decl_dict,
548
540
                        source_ref = source_ref
549
541
                    ),
550
542
                    source_ref = source_ref
563
555
        ),
564
556
    )
565
557
 
 
558
    if Utils.python_version >= 340:
 
559
        class_assign = statements[-1]
 
560
 
 
561
        # assert False, class_creation_function
 
562
        class_creation_function.qualname_setup = class_assign, qualname_assign
 
563
 
 
564
 
 
565
 
566
566
    final = (
567
567
        StatementDelVariable(
568
568
            variable_ref = ExpressionTargetTempVariableRef(
569
 
                variable   = tmp_bases.makeReference(provider),
570
 
                source_ref = source_ref
571
 
            ),
572
 
            tolerant   = True,
573
 
            source_ref = source_ref
574
 
        ),
575
 
        StatementDelVariable(
576
 
            variable_ref = ExpressionTargetTempVariableRef(
577
 
                variable   = tmp_class_decl_dict.makeReference(provider),
578
 
                source_ref = source_ref
579
 
            ),
580
 
            tolerant   = True,
581
 
            source_ref = source_ref
582
 
        ),
583
 
        StatementDelVariable(
584
 
            variable_ref = ExpressionTargetTempVariableRef(
585
 
                variable   = tmp_metaclass.makeReference(provider),
586
 
                source_ref = source_ref
587
 
            ),
588
 
            tolerant   = True,
589
 
            source_ref = source_ref
590
 
        ),
591
 
        StatementDelVariable(
592
 
            variable_ref = ExpressionTargetTempVariableRef(
593
 
                variable   = tmp_prepared.makeReference(provider),
 
569
                variable   = tmp_bases,
 
570
                source_ref = source_ref
 
571
            ),
 
572
            tolerant   = True,
 
573
            source_ref = source_ref
 
574
        ),
 
575
        StatementDelVariable(
 
576
            variable_ref = ExpressionTargetTempVariableRef(
 
577
                variable   = tmp_class_decl_dict,
 
578
                source_ref = source_ref
 
579
            ),
 
580
            tolerant   = True,
 
581
            source_ref = source_ref
 
582
        ),
 
583
        StatementDelVariable(
 
584
            variable_ref = ExpressionTargetTempVariableRef(
 
585
                variable   = tmp_metaclass,
 
586
                source_ref = source_ref
 
587
            ),
 
588
            tolerant   = True,
 
589
            source_ref = source_ref
 
590
        ),
 
591
        StatementDelVariable(
 
592
            variable_ref = ExpressionTargetTempVariableRef(
 
593
                variable   = tmp_prepared,
594
594
                source_ref = source_ref
595
595
            ),
596
596
            tolerant   = True,
696
696
    statements = [
697
697
        StatementAssignmentVariable(
698
698
            variable_ref = ExpressionTargetTempVariableRef(
699
 
                variable   = tmp_bases.makeReference( provider ),
 
699
                variable   = tmp_bases,
700
700
                source_ref = source_ref
701
701
            ),
702
702
            source       = makeSequenceCreationOrConstant(
710
710
        ),
711
711
        StatementAssignmentVariable(
712
712
            variable_ref = ExpressionTargetTempVariableRef(
713
 
                variable   = tmp_class_dict.makeReference(provider),
 
713
                variable   = tmp_class_dict,
714
714
                source_ref = source_ref
715
715
            ),
716
716
            source       =   ExpressionFunctionCall(
731
731
        ),
732
732
        StatementAssignmentVariable(
733
733
            variable_ref = ExpressionTargetTempVariableRef(
734
 
                variable   = tmp_metaclass.makeReference(provider),
 
734
                variable   = tmp_metaclass,
735
735
                source_ref = source_ref
736
736
            ),
737
737
            source       = ExpressionConditional(
743
743
                        user_provided = True
744
744
                    ),
745
745
                    right      = ExpressionTempVariableRef(
746
 
                        variable   = tmp_class_dict.makeReference(provider),
 
746
                        variable   = tmp_class_dict,
747
747
                        source_ref = source_ref
748
748
                    ),
749
749
                    source_ref = source_ref
750
750
                ),
751
751
                yes_expression = ExpressionDictOperationGet(
752
752
                    dicte = ExpressionTempVariableRef(
753
 
                        variable   = tmp_class_dict.makeReference(provider),
 
753
                        variable   = tmp_class_dict,
754
754
                        source_ref = source_ref
755
755
                    ),
756
756
                    key   = ExpressionConstantRef(
763
763
                no_expression = ExpressionSelectMetaclass(
764
764
                    metaclass = None,
765
765
                    bases     = ExpressionTempVariableRef(
766
 
                        variable   = tmp_bases.makeReference( provider ),
 
766
                        variable   = tmp_bases,
767
767
                        source_ref = source_ref
768
768
                    ),
769
769
                    source_ref = source_ref
774
774
        ),
775
775
        StatementAssignmentVariable(
776
776
            variable_ref = ExpressionTargetTempVariableRef(
777
 
                variable   = tmp_class.makeReference(provider),
 
777
                variable   = tmp_class,
778
778
                source_ref = source_ref
779
779
            ),
780
780
            source     = ExpressionCallNoKeywords(
781
781
                called         = ExpressionTempVariableRef(
782
 
                    variable   = tmp_metaclass.makeReference(provider),
 
782
                    variable   = tmp_metaclass,
783
783
                    source_ref = source_ref
784
784
                ),
785
785
                args           = ExpressionMakeTuple(
790
790
                            user_provided = True
791
791
                        ),
792
792
                        ExpressionTempVariableRef(
793
 
                            variable   = tmp_bases.makeReference( provider ),
 
793
                            variable   = tmp_bases,
794
794
                            source_ref = source_ref
795
795
                        ),
796
796
                        ExpressionTempVariableRef(
797
 
                            variable   = tmp_class_dict.makeReference(
798
 
                                provider
799
 
                            ),
 
797
                            variable   = tmp_class_dict,
800
798
                            source_ref = source_ref
801
799
                        )
802
800
                    ),
816
814
        statements.append(
817
815
            StatementAssignmentVariable(
818
816
                variable_ref = ExpressionTargetTempVariableRef(
819
 
                    variable   = tmp_class.makeReference(provider),
 
817
                    variable   = tmp_class,
820
818
                    source_ref = source_ref
821
819
                ),
822
820
                source       = ExpressionCallNoKeywords(
824
822
                    args       = ExpressionMakeTuple(
825
823
                        elements  = (
826
824
                            ExpressionTempVariableRef(
827
 
                                variable   = tmp_class.makeReference(
828
 
                                    provider
829
 
                                ),
 
825
                                variable   = tmp_class,
830
826
                                source_ref = source_ref
831
827
                            ),
832
828
                        ),
845
841
                source_ref    = source_ref
846
842
            ),
847
843
            source     = ExpressionTempVariableRef(
848
 
                variable   = tmp_class.makeReference(provider),
 
844
                variable   = tmp_class,
849
845
                source_ref = source_ref
850
846
            ),
851
847
            source_ref = source_ref
855
851
    final = (
856
852
        StatementDelVariable(
857
853
            variable_ref = ExpressionTargetTempVariableRef(
858
 
                variable   = tmp_class.makeReference(provider),
859
 
                source_ref = source_ref
860
 
            ),
861
 
            tolerant   = True,
862
 
            source_ref = source_ref
863
 
        ),
864
 
        StatementDelVariable(
865
 
            variable_ref = ExpressionTargetTempVariableRef(
866
 
                variable   = tmp_bases.makeReference( provider ),
867
 
                source_ref = source_ref
868
 
            ),
869
 
            tolerant   = True,
870
 
            source_ref = source_ref
871
 
        ),
872
 
        StatementDelVariable(
873
 
            variable_ref = ExpressionTargetTempVariableRef(
874
 
                variable   = tmp_class_dict.makeReference(provider),
875
 
                source_ref = source_ref
876
 
            ),
877
 
            tolerant   = True,
878
 
            source_ref = source_ref
879
 
        ),
880
 
        StatementDelVariable(
881
 
            variable_ref = ExpressionTargetTempVariableRef(
882
 
                variable   = tmp_metaclass.makeReference(provider),
 
854
                variable   = tmp_class,
 
855
                source_ref = source_ref
 
856
            ),
 
857
            tolerant   = True,
 
858
            source_ref = source_ref
 
859
        ),
 
860
        StatementDelVariable(
 
861
            variable_ref = ExpressionTargetTempVariableRef(
 
862
                variable   = tmp_bases,
 
863
                source_ref = source_ref
 
864
            ),
 
865
            tolerant   = True,
 
866
            source_ref = source_ref
 
867
        ),
 
868
        StatementDelVariable(
 
869
            variable_ref = ExpressionTargetTempVariableRef(
 
870
                variable   = tmp_class_dict,
 
871
                source_ref = source_ref
 
872
            ),
 
873
            tolerant   = True,
 
874
            source_ref = source_ref
 
875
        ),
 
876
        StatementDelVariable(
 
877
            variable_ref = ExpressionTargetTempVariableRef(
 
878
                variable   = tmp_metaclass,
883
879
                source_ref = source_ref
884
880
            ),
885
881
            tolerant   = True,